maestro-agent 0.0.1 → 0.0.2

package/src/scheduler/index.ts

@@ -0,0 +1,461 @@
+import type { Database } from "bun:sqlite";
+import { generateId, now } from "../core/db";
+import type { HubContext } from "../core/server";
+import { proposeRoster } from "../chief";
+import { claimTaskForAgent } from "../api/tasks";
+
+export interface ExecutionResult {
+  executed: number;
+  blocked: number;
+}
+
+export interface ScheduledTaskExecutionResult {
+  fired: number;
+  created: number;
+  assigned: number;
+  blocked: number;
+}
+
+export function executeHooksForEvent(db: Database, event: string, payload: Record<string, any>): ExecutionResult {
+  const hooks = db.query("SELECT * FROM hook_binding WHERE event = ? AND enabled = 1 ORDER BY created_at ASC").all(event) as any[];
+  const result = { executed: 0, blocked: 0 };
+
+  for (const hook of hooks) {
+    if (!scopeMatches(hook, payload)) continue;
+    if (hook.when_expr && !evaluateWhenExpression(hook.when_expr, payload)) continue;
+    const action = parseAction(hook.action);
+    const guard = checkExecutionGuards(db, hook, action, payload);
+    if (!guard.allowed) {
+      result.blocked++;
+      continue;
+    }
+    const outcome = executeAction(db, action, payload);
+    result.executed += outcome.executed;
+    result.blocked += outcome.blocked;
+    if (outcome.executed > 0) recordGuardExecution(db, hook, action, payload);
+  }
+
+  return result;
+}
+
+function checkExecutionGuards(db: Database, binding: any, action: any, payload: Record<string, any>) {
+  const idempotencyKey = renderTemplate(action.idempotency_key, payload);
+  if (idempotencyKey) {
+    const exists = db.query("SELECT id FROM event_log WHERE type = 'hook.idempotency' AND payload_json = ? LIMIT 1").get(idempotencyKey);
+    if (exists) return { allowed: false };
+  }
+
+  const rateLimit = action.rate_limit;
+  if (rateLimit?.max && rateLimit?.window_ms) {
+    const since = now() - Number(rateLimit.window_ms);
+    const count = (db.query(
+      "SELECT COUNT(*) AS count FROM event_log WHERE type = 'hook.fired' AND payload_json = ? AND created_at >= ?",
+    ).get(binding.id, since) as any).count;
+    if (count >= Number(rateLimit.max)) {
+      disableHookAndAlert(db, binding.id, `Hook ${binding.id} exceeded rate limit`);
+      return { allowed: false };
+    }
+  }
+
+  return { allowed: true };
+}
+
+function recordGuardExecution(db: Database, binding: any, action: any, payload: Record<string, any>) {
+  const ts = now();
+  db.run("INSERT INTO event_log (id, type, payload_json, created_at) VALUES (?, 'hook.fired', ?, ?)", [
+    generateId("evt"),
+    binding.id,
+    ts,
+  ]);
+
+  const idempotencyKey = renderTemplate(action.idempotency_key, payload);
+  if (idempotencyKey) {
+    db.run("INSERT INTO event_log (id, type, payload_json, created_at) VALUES (?, 'hook.idempotency', ?, ?)", [
+      generateId("evt"),
+      idempotencyKey,
+      ts,
+    ]);
+  }
+}
+
+function disableHookAndAlert(db: Database, hookId: string, body: string) {
+  const ts = now();
+  db.run("UPDATE hook_binding SET enabled = 0 WHERE id = ?", [hookId]);
+  db.run(
+    `INSERT INTO inbox_message (id, kind, from_actor, to_actor, subject, body, ref_json, status, created_at)
+     VALUES (?, 'escalation', 'scheduler', 'user', 'Hook rate limit exceeded', ?, ?, 'unread', ?)`,
+    [generateId("msg"), body, JSON.stringify({ hook_id: hookId }), ts],
+  );
+}
+
+function evaluateWhenExpression(expr: string, payload: Record<string, any>): boolean {
+  return expr
+    .split("&&")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .every((part) => evaluateComparison(part, payload));
+}
+
+function evaluateComparison(expr: string, payload: Record<string, any>): boolean {
+  const match = expr.match(/^([A-Za-z0-9_.]+)\s*(==|!=)\s*['"]?([^'"]+)['"]?$/);
+  if (!match) return false;
+  const [, path, op, expected] = match;
+  const actual = getPath(payload, path);
+  return op === "==" ? String(actual) === expected : String(actual) !== expected;
+}
+
+function getPath(source: Record<string, any>, path: string): unknown {
+  return path.split(".").reduce((value: any, key) => value?.[key], source);
+}
+
+function renderTemplate(template: string | undefined, payload: Record<string, any>): string | null {
+  if (!template) return null;
+  return template.replace(/\{\{([A-Za-z0-9_.]+)\}\}/g, (_match, path) => String(getPath(payload, path) ?? ""));
+}
+
+export function runDueCrons(db: Database, firedAt = now()): ExecutionResult {
+  const crons = db.query("SELECT * FROM cron_binding WHERE enabled = 1 ORDER BY created_at ASC").all() as any[];
+  const result = { executed: 0, blocked: 0 };
+
+  for (const cron of crons) {
+    if (!isCronDue(cron, firedAt)) continue;
+    const action = parseAction(cron.action);
+    const outcome = executeAction(db, action, { scope: cron.scope, scope_id: cron.scope_id });
+    result.executed += outcome.executed;
+    result.blocked += outcome.blocked;
+    if (outcome.executed > 0) {
+      db.run("UPDATE cron_binding SET last_fired_at = ? WHERE id = ?", [firedAt, cron.id]);
+    }
+  }
+
+  return result;
+}
+
+export async function runDueScheduledTasks(ctx: HubContext, firedAt = now()): Promise<ScheduledTaskExecutionResult> {
+  const rows = ctx.db.query(
+    `SELECT * FROM scheduled_task
+     WHERE enabled = 1 AND next_fire_at IS NOT NULL AND next_fire_at <= ?
+     ORDER BY next_fire_at ASC, created_at ASC`,
+  ).all(firedAt) as any[];
+  const result = { fired: 0, created: 0, assigned: 0, blocked: 0 };
+
+  for (const scheduled of rows) {
+    result.fired++;
+
+    // Dedup: skip if there's already a pending/active task from this scheduled_task
+    const existingTask = ctx.db.query(
+      `SELECT id FROM task
+       WHERE created_by = 'scheduled_task'
+         AND project_id = ?
+         AND title = ?
+         AND status IN ('open', 'claimed', 'in_progress')
+       LIMIT 1`,
+    ).get(scheduled.project_id, scheduled.title) as any;
+    if (existingTask) {
+      result.blocked++;
+      // Still advance next_fire_at so we don't re-fire immediately
+      const nextFireAt = scheduled.schedule_type === "cron"
+        ? computeNextFireAt({ schedule_type: "cron", cron_expr: scheduled.cron_expr }, firedAt)
+        : null;
+      const enabled = scheduled.schedule_type === "once" ? 0 : scheduled.enabled;
+      ctx.db.run(
+        `UPDATE scheduled_task SET enabled = ?, last_fired_at = ?, next_fire_at = ?, updated_at = ? WHERE id = ?`,
+        [enabled, firedAt, nextFireAt, now(), scheduled.id],
+      );
+      continue;
+    }
+
+    const role = resolveScheduledRole(ctx.db, scheduled);
+    const agent = role ? resolveAgentForRole(ctx.db, role.id) : null;
+    const taskId = generateId("task");
+    const ts = now();
+    ctx.db.run(
+      `INSERT INTO task (id, project_id, title, description, status, priority, assignee_agent_id, required_capabilities_json, lineage_depth, created_by, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'open', ?, NULL, '[]', 0, 'scheduled_task', ?, ?)`,
+      [
+        taskId,
+        scheduled.project_id,
+        scheduled.title,
+        scheduled.description || null,
+        scheduled.priority || 0,
+        ts,
+        ts,
+      ],
+    );
+    result.created++;
+    ctx.bus?.publish?.("task.created", {
+      id: taskId,
+      project_id: scheduled.project_id,
+      title: scheduled.title,
+      scheduled_task_id: scheduled.id,
+    });
+
+    if (agent) {
+      const claimResult = await claimTaskForAgent(ctx, taskId, agent.id, { deferIfProjectBusy: true });
+      if ("error" in claimResult || "deferred" in claimResult) {
+        result.blocked++;
+      } else {
+        result.assigned++;
+      }
+    } else if (scheduled.assignee_role_id || scheduled.assignee_role_name) {
+      result.blocked++;
+    }
+
+    const nextFireAt = scheduled.schedule_type === "cron"
+      ? computeNextFireAt({ schedule_type: "cron", cron_expr: scheduled.cron_expr }, firedAt)
+      : null;
+
+    if (scheduled.schedule_type === "cron" && nextFireAt === null) {
+      // Cannot determine next fire time — disable the task to prevent silent death
+      ctx.db.run(
+        `UPDATE scheduled_task
+         SET enabled = 0, last_fired_at = ?, next_fire_at = NULL, last_task_id = ?, updated_at = ?
+         WHERE id = ?`,
+        [firedAt, taskId, ts, scheduled.id],
+      );
+      ctx.db.run(
+        "INSERT INTO event_log (id, type, payload_json, created_at) VALUES (?, 'scheduled_task.disabled', ?, ?)",
+        [
+          generateId("evt"),
+          JSON.stringify({ scheduled_task_id: scheduled.id, reason: "no_next_fire_at", cron_expr: scheduled.cron_expr }),
+          ts,
+        ],
+      );
+      continue;
+    }
+
+    const enabled = scheduled.schedule_type === "once" ? 0 : scheduled.enabled;
+    ctx.db.run(
+      `UPDATE scheduled_task
+       SET enabled = ?, last_fired_at = ?, next_fire_at = ?, last_task_id = ?, updated_at = ?
+       WHERE id = ?`,
+      [enabled, firedAt, nextFireAt, taskId, ts, scheduled.id],
+    );
+    ctx.db.run(
+      "INSERT INTO event_log (id, type, payload_json, created_at) VALUES (?, 'scheduled_task.fired', ?, ?)",
+      [
+        generateId("evt"),
+        JSON.stringify({ scheduled_task_id: scheduled.id, task_id: taskId, agent_id: agent?.id || null }),
+        ts,
+      ],
+    );
+  }
+
+  return result;
+}
+
+export function computeNextFireAt(
+  input: { schedule_type: string; cron_expr?: string | null; run_at?: number | null },
+  from = now(),
+): number | null {
+  if (input.schedule_type === "once") {
+    const runAt = Number(input.run_at || 0);
+    return runAt > 0 ? runAt : null;
+  }
+  if (input.schedule_type !== "cron") return null;
+  const parsed = parseCronExpression(input.cron_expr || "");
+  let cursor = Math.floor(from / 60_000) * 60_000 + 60_000;
+  const deadline = cursor + 366 * 24 * 60 * 60_000;
+  while (cursor <= deadline) {
+    if (cronMatches(parsed, new Date(cursor))) return cursor;
+    cursor += 60_000;
+  }
+  return null;
+}
+
+export function validateScheduleInput(input: { schedule_type?: string; cron_expr?: string | null; run_at?: number | null }) {
+  const scheduleType = input.schedule_type || (input.cron_expr ? "cron" : "once");
+  if (scheduleType !== "cron" && scheduleType !== "once") {
+    throw new Error("schedule_type must be cron or once");
+  }
+  if (scheduleType === "cron") {
+    parseCronExpression(input.cron_expr || "");
+  } else if (!Number(input.run_at || 0)) {
+    throw new Error("run_at is required for one-time scheduled tasks");
+  }
+  return scheduleType;
+}
+
+function executeAction(db: Database, action: any, payload: Record<string, any>): ExecutionResult {
+  if (action.type === "spawn_task") {
+    return spawnTask(db, action, payload);
+  }
+  if (action.type === "create_task") {
+    return createTask(db, action, payload);
+  }
+  if (action.type === "chief_heartbeat") {
+    return chiefHeartbeat(db, action, payload);
+  }
+  return { executed: 0, blocked: 1 };
+}
+
+function spawnTask(db: Database, action: any, payload: Record<string, any>): ExecutionResult {
+  const parentId = payload.task_id || action.parent_task_id;
+  const parent = db.query("SELECT * FROM task WHERE id = ?").get(parentId) as any;
+  if (!parent) return { executed: 0, blocked: 1 };
+  if ((parent.lineage_depth || 0) >= 10) return { executed: 0, blocked: 1 };
+  insertTask(db, {
+    project_id: parent.project_id,
+    parent_task_id: parent.id,
+    title: action.title || `Follow up: ${parent.title}`,
+    required_capabilities: action.skill ? [action.skill] : [],
+    lineage_depth: (parent.lineage_depth || 0) + 1,
+    created_by: "hook",
+  });
+  return { executed: 1, blocked: 0 };
+}
+
+function createTask(db: Database, action: any, payload: Record<string, any>): ExecutionResult {
+  const projectId = action.project_id || (payload.scope === "project" ? payload.scope_id : null);
+  if (!projectId || !action.title) return { executed: 0, blocked: 1 };
+  insertTask(db, {
+    project_id: projectId,
+    parent_task_id: null,
+    title: action.title,
+    required_capabilities: action.skill ? [action.skill] : [],
+    lineage_depth: 0,
+    created_by: "cron",
+  });
+  return { executed: 1, blocked: 0 };
+}
+
+function chiefHeartbeat(db: Database, action: any, payload: Record<string, any>): ExecutionResult {
+  const workspaceId = action.workspace_id || (payload.scope === "workspace" ? payload.scope_id : null);
+  const workspaces = workspaceId
+    ? [{ id: workspaceId }]
+    : db.query("SELECT id FROM workspace WHERE status = 'active'").all() as Array<{ id: string }>;
+  let executed = 0;
+  let blocked = 0;
+  for (const workspace of workspaces) {
+    const exists = db.query("SELECT id FROM workspace WHERE id = ?").get(workspace.id);
+    if (!exists) {
+      blocked++;
+      continue;
+    }
+    proposeRoster(db, workspace.id);
+    executed++;
+  }
+  return { executed, blocked };
+}
+
+function insertTask(
+  db: Database,
+  input: {
+    project_id: string;
+    parent_task_id: string | null;
+    title: string;
+    required_capabilities: string[];
+    lineage_depth: number;
+    created_by: string;
+  },
+) {
+  const ts = now();
+  db.run(
+    `INSERT INTO task (id, project_id, parent_task_id, title, description, status, required_capabilities_json, priority, lineage_depth, created_by, created_at, updated_at)
+     VALUES (?, ?, ?, ?, '', 'open', ?, 0, ?, ?, ?, ?)`,
+    [
+      generateId("task"),
+      input.project_id,
+      input.parent_task_id,
+      input.title,
+      JSON.stringify(input.required_capabilities),
+      input.lineage_depth,
+      input.created_by,
+      ts,
+      ts,
+    ],
+  );
+}
+
+function resolveScheduledRole(db: Database, scheduled: any) {
+  if (scheduled.assignee_role_id) {
+    const role = db.query("SELECT * FROM role WHERE id = ? AND workspace_id = ?").get(scheduled.assignee_role_id, scheduled.workspace_id) as any;
+    if (role) return role;
+  }
+  if (scheduled.assignee_role_name) {
+    return db.query(
+      "SELECT * FROM role WHERE workspace_id = ? AND LOWER(name) = LOWER(?) ORDER BY created_at ASC LIMIT 1",
+    ).get(scheduled.workspace_id, scheduled.assignee_role_name) as any;
+  }
+  return null;
+}
+
+function resolveAgentForRole(db: Database, roleId: string) {
+  return db.query(
+    `SELECT * FROM agent
+     WHERE role_id = ? AND status != 'offline'
+     ORDER BY CASE status WHEN 'idle' THEN 0 WHEN 'working' THEN 1 ELSE 2 END, last_active_at DESC
+     LIMIT 1`,
+  ).get(roleId) as any;
+}
+
+function scopeMatches(binding: any, payload: Record<string, any>): boolean {
+  if (binding.scope === "project") return binding.scope_id === payload.project_id;
+  if (binding.scope === "task") return binding.scope_id === payload.task_id;
+  if (binding.scope === "workspace") return binding.scope_id === payload.workspace_id;
+  return true;
+}
+
+function parseAction(raw: string) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { type: raw };
+  }
+}
+
+function isCronDue(cron: any, firedAt: number): boolean {
+  if (!cron.last_fired_at) return true;
+  if (cron.cron_expr === "* * * * *") return firedAt - cron.last_fired_at >= 60_000;
+  return firedAt > cron.last_fired_at;
+}
+
+function parseCronExpression(expr: string): number[][] {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error("cron_expr must use 5 fields: minute hour day-of-month month day-of-week");
+  return [
+    parseCronField(parts[0], 0, 59),
+    parseCronField(parts[1], 0, 23),
+    parseCronField(parts[2], 1, 31),
+    parseCronField(parts[3], 1, 12),
+    parseCronField(parts[4], 0, 7),
+  ];
+}
+
+function parseCronField(raw: string, min: number, max: number): number[] {
+  const values = new Set<number>();
+  for (const part of raw.split(",")) {
+    const value = part.trim();
+    if (!value) throw new Error("Invalid cron field");
+    const [rangeRaw, stepRaw] = value.split("/");
+    const step = stepRaw === undefined ? 1 : Number(stepRaw);
+    if (!Number.isInteger(step) || step <= 0) throw new Error(`Invalid cron step: ${value}`);
+    let start: number;
+    let end: number;
+    if (rangeRaw === "*") {
+      start = min;
+      end = max;
+    } else if (rangeRaw.includes("-")) {
+      const [a, b] = rangeRaw.split("-").map(Number);
+      start = a;
+      end = b;
+    } else {
+      start = Number(rangeRaw);
+      end = start;
+    }
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < min || end > max || start > end) {
+      throw new Error(`Invalid cron field: ${value}`);
+    }
+    for (let i = start; i <= end; i += step) values.add(i === 7 && min === 0 && max === 7 ? 0 : i);
+  }
+  return [...values].sort((a, b) => a - b);
+}
+
+function cronMatches(parsed: number[][], date: Date): boolean {
+  const [minutes, hours, days, months, dows] = parsed;
+  return minutes.includes(date.getMinutes())
+    && hours.includes(date.getHours())
+    && days.includes(date.getDate())
+    && months.includes(date.getMonth() + 1)
+    && dows.includes(date.getDay());
+}

package/src/session/output-parser.ts

@@ -0,0 +1,75 @@
+export interface ParsedTranscript {
+  summary: string | null;
+  filesChanged: string[];
+  artifacts: Array<{ kind: string; path: string }>;
+}
+
+/**
+ * Parse a session transcript to extract structured results.
+ * Uses heuristics to find summary text and file operations.
+ */
+export function parseTranscript(transcript: string): ParsedTranscript {
+  const filesChanged = extractFilesChanged(transcript);
+  const summary = extractSummary(transcript);
+  const artifacts = extractArtifacts(transcript);
+  return { summary, filesChanged, artifacts };
+}
+
+function extractFilesChanged(text: string): string[] {
+  const files = new Set<string>();
+  const patterns = [
+    /(?:Write|Edit|Read)\(file_path="([^"]+)"/g,
+    /(?:Write|Edit)\s*\(\s*file_path\s*[:=]\s*"([^"]+)"/g,
+    /file_path="([^"]+)"/g,
+  ];
+  for (const pattern of patterns) {
+    for (const m of text.matchAll(pattern)) {
+      if (m[1] && !m[1].includes("test")) files.add(m[1]);
+    }
+  }
+  return [...files];
+}
+
+function extractSummary(text: string): string | null {
+  if (!text.trim()) return null;
+
+  // Strategy 1: Look for explicit summary heading
+  const summaryMatch = text.match(/##\s*Summary\s*\n([\s\S]+?)(?=\n##|\n---|$)/i);
+  if (summaryMatch) {
+    return summaryMatch[1].trim().slice(0, 1000);
+  }
+
+  // Strategy 2: Take the last meaningful paragraph (likely the conclusion)
+  const lines = text.trim().split("\n");
+  const blocks: string[] = [];
+  let current: string[] = [];
+  for (const line of lines) {
+    if (line.trim() === "") {
+      if (current.length > 0) {
+        blocks.push(current.join("\n"));
+        current = [];
+      }
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.length > 0) blocks.push(current.join("\n"));
+
+  // Filter out tool call blocks, keep text blocks
+  const textBlocks = blocks.filter(
+    (b) => !b.startsWith("{") && !b.includes("file_path=") && b.length > 20
+  );
+  if (textBlocks.length === 0) return null;
+
+  const last = textBlocks[textBlocks.length - 1];
+  return last.slice(0, 1000);
+}
+
+function extractArtifacts(text: string): Array<{ kind: string; path: string }> {
+  const artifacts: Array<{ kind: string; path: string }> = [];
+  const writePattern = /Write\(file_path="([^"]+)"/g;
+  for (const m of text.matchAll(writePattern)) {
+    artifacts.push({ kind: "file_created", path: m[1] });
+  }
+  return artifacts;
+}

package/src/session/realtime-parser.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from "events";
+
+export interface SessionEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Parses a stream of text chunks and emits structured JSON-line events.
+ * Events must be a single JSON object per line with a "type" field.
+ */
+export class RealtimeParser extends EventEmitter {
+  private buffer = "";
+
+  feed(chunk: string): void {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    // Keep last partial line in buffer
+    this.buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("{")) continue;
+      try {
+        const obj = JSON.parse(trimmed);
+        if (typeof obj === "object" && obj !== null && typeof obj.type === "string") {
+          this.emit("event", obj as SessionEvent);
+        }
+      } catch {
+        // Not valid JSON, skip
+      }
+    }
+  }
+
+  flush(): void {
+    if (this.buffer.trim()) {
+      this.feed("\n");
+    }
+  }
+}