maestro-agent 0.0.1 → 0.0.2

package/src/workflows/index.ts

@@ -0,0 +1,231 @@
+import type { Database } from "bun:sqlite";
+import type { HubContext } from "../core/server";
+import { generateId, now } from "../core/db";
+import { executeHooksForEvent } from "../scheduler";
+import { unlockDependents } from "../ops/task-deps";
+
+export interface WorkflowStatus {
+  id: string;
+  label: string;
+  terminal?: boolean;
+}
+
+export interface WorkflowAction {
+  id: string;
+  label: string;
+  from: string[];
+  to: string;
+  requires?: string[];
+  clears_assignee?: boolean;
+  terminal?: boolean;
+}
+
+export interface WorkflowDefinition {
+  id: string;
+  name: string;
+  initial_status: string;
+  blocked_status: string;
+  done_status: string;
+  statuses: WorkflowStatus[];
+  actions: WorkflowAction[];
+}
+
+export const DEFAULT_WORKFLOW: WorkflowDefinition = {
+  id: "workflow_default",
+  name: "Default Task Workflow",
+  initial_status: "open",
+  blocked_status: "blocked",
+  done_status: "done",
+  statuses: [
+    { id: "open", label: "Open" },
+    { id: "claimed", label: "In Progress" },
+    { id: "review", label: "Review" },
+    { id: "blocked", label: "Blocked" },
+    { id: "done", label: "Done", terminal: true },
+    { id: "abandoned", label: "Abandoned", terminal: true },
+  ],
+  actions: [
+    { id: "claim", label: "Claim", from: ["open"], to: "claimed" },
+    { id: "submit", label: "Submit for Review", from: ["claimed"], to: "review", requires: ["summary"] },
+    { id: "complete", label: "Complete", from: ["claimed", "review"], to: "done", requires: ["summary"], terminal: true },
+    { id: "block", label: "Block", from: ["open", "claimed", "review"], to: "blocked", requires: ["reason"] },
+    { id: "return", label: "Return", from: ["claimed", "review", "blocked"], to: "open", requires: ["reason"], clears_assignee: true },
+    { id: "abandon", label: "Abandon", from: ["open", "claimed", "review", "blocked"], to: "abandoned", requires: ["reason"], clears_assignee: true, terminal: true },
+  ],
+};
+
+export function ensureDefaultWorkflow(db: Database) {
+  const ts = now();
+  db.run(
+    `INSERT INTO workflow_definition (id, scope, scope_id, name, definition_json, created_at, updated_at)
+     VALUES (?, 'global', NULL, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       name = excluded.name,
+       definition_json = excluded.definition_json,
+       updated_at = excluded.updated_at`,
+    [DEFAULT_WORKFLOW.id, DEFAULT_WORKFLOW.name, JSON.stringify(DEFAULT_WORKFLOW), ts, ts],
+  );
+}
+
+export function getWorkflowForTask(db: Database, taskId: string): WorkflowDefinition {
+  const row = db.query(`
+    SELECT wf.*
+    FROM task
+    JOIN project ON project.id = task.project_id
+    LEFT JOIN workflow_definition wf ON wf.id = project.workflow_id
+    WHERE task.id = ?
+  `).get(taskId) as any | null;
+
+  if (row?.definition_json) return parseWorkflow(row.definition_json);
+
+  const fallback = db.query("SELECT * FROM workflow_definition WHERE id = ?").get(DEFAULT_WORKFLOW.id) as any | null;
+  if (fallback?.definition_json) return parseWorkflow(fallback.definition_json);
+  return DEFAULT_WORKFLOW;
+}
+
+export function listTaskActions(db: Database, taskId: string) {
+  const task = db.query("SELECT * FROM task WHERE id = ?").get(taskId) as any | null;
+  if (!task) throw new Error(`Task not found: ${taskId}`);
+  const workflow = getWorkflowForTask(db, taskId);
+  const actions = workflow.actions.filter((action) => action.from.includes(task.status));
+  return {
+    task_id: taskId,
+    status: task.status,
+    workflow: {
+      id: workflow.id,
+      name: workflow.name,
+      statuses: workflow.statuses,
+    },
+    actions,
+  };
+}
+
+export function transitionTask(
+  ctx: Pick<HubContext, "db" | "bus">,
+  taskId: string,
+  actionId: string,
+  input: Record<string, any> = {},
+  opts: { actorId?: string } = {},
+): { ok: true; task: any; action: WorkflowAction; workflow: WorkflowDefinition } | { ok: false; error: string; status: number } {
+  const task = ctx.db.query("SELECT * FROM task WHERE id = ?").get(taskId) as any | null;
+  if (!task) return { ok: false, error: "Task not found", status: 404 };
+
+  const workflow = getWorkflowForTask(ctx.db, taskId);
+  const action = workflow.actions.find((candidate) => candidate.id === actionId);
+  if (!action) return { ok: false, error: `Workflow action not found: ${actionId}`, status: 404 };
+  if (!action.from.includes(task.status)) {
+    return { ok: false, error: `Action "${actionId}" is not available from status "${task.status}"`, status: 409 };
+  }
+
+  const missing = (action.requires || []).filter((field) => !isPresent(input[field]));
+  if (missing.length > 0) {
+    return { ok: false, error: `Missing required field(s): ${missing.join(", ")}`, status: 400 };
+  }
+
+  const ts = now();
+  const updates = ["status = ?", "updated_at = ?"];
+  const values: any[] = [action.to, ts];
+  if (action.clears_assignee) {
+    updates.push("assignee_agent_id = NULL", "claim_token = NULL");
+  }
+  values.push(taskId);
+  ctx.db.run(`UPDATE task SET ${updates.join(", ")} WHERE id = ?`, values);
+
+  const actor = opts.actorId || "system";
+  const summary = input.summary || input.reason || input.note || "";
+  const content = summary ? `${action.id}: ${summary}` : action.id;
+  ctx.db.run(
+    "INSERT INTO task_thread_item (id, task_id, kind, author, content, created_at) VALUES (?, ?, 'workflow_transition', ?, ?, ?)",
+    [generateId("ti"), taskId, actor, content, ts],
+  );
+
+  const updated = ctx.db.query("SELECT * FROM task WHERE id = ?").get(taskId) as any;
+  const eventPayload = {
+    id: taskId,
+    action_id: action.id,
+    from_status: task.status,
+    to_status: action.to,
+    actor_id: actor,
+  };
+  ctx.bus.publish("task.transitioned", eventPayload);
+  ctx.bus.publish(`task.${action.id}`, eventPayload);
+
+  if (isTerminal(workflow, action.to) || action.terminal) {
+    executeHooksForEvent(ctx.db, `task.${action.id}`, { task_id: taskId, project_id: task.project_id });
+  }
+  if (action.to === workflow.done_status) {
+    unlockDependents(ctx as HubContext, taskId, {
+      doneStatus: workflow.done_status,
+      blockedStatus: workflow.blocked_status,
+      openStatus: workflow.initial_status,
+    });
+    // Auto-archive completed scheduled task instances
+    if (task.created_by === "scheduled_task") {
+      ctx.db.run("UPDATE task SET archived_at = ? WHERE id = ?", [now(), taskId]);
+    }
+  }
+
+  return { ok: true, task: updated, action, workflow };
+}
+
+export function workflowStatusesForProject(db: Database, projectId?: string | null): WorkflowStatus[] {
+  let workflow: WorkflowDefinition = DEFAULT_WORKFLOW;
+  if (projectId) {
+    const task = db.query("SELECT id FROM task WHERE project_id = ? LIMIT 1").get(projectId) as any | null;
+    if (task) workflow = getWorkflowForTask(db, task.id);
+    else {
+      const row = db.query(`
+        SELECT wf.definition_json
+        FROM project
+        LEFT JOIN workflow_definition wf ON wf.id = project.workflow_id
+        WHERE project.id = ?
+      `).get(projectId) as any | null;
+      workflow = row?.definition_json ? parseWorkflow(row.definition_json) : defaultWorkflowFromDb(db);
+    }
+  } else {
+    workflow = defaultWorkflowFromDb(db);
+  }
+  return workflow.statuses;
+}
+
+export function isInitialTaskStatus(db: Database, task: any): boolean {
+  const workflow = getWorkflowForTask(db, task.id);
+  return task.status === workflow.initial_status;
+}
+
+export function isBlockedTaskStatus(db: Database, task: any): boolean {
+  const workflow = getWorkflowForTask(db, task.id);
+  return task.status === workflow.blocked_status;
+}
+
+export function isActiveTaskStatus(db: Database, task: any): boolean {
+  const workflow = getWorkflowForTask(db, task.id);
+  return !workflow.statuses.find((status) => status.id === task.status)?.terminal;
+}
+
+export function countTasksByPredicate(db: Database, predicate: (task: any) => boolean): number {
+  const tasks = db.query("SELECT * FROM task").all() as any[];
+  return tasks.filter(predicate).length;
+}
+
+function defaultWorkflowFromDb(db: Database) {
+  const row = db.query("SELECT definition_json FROM workflow_definition WHERE id = ?").get(DEFAULT_WORKFLOW.id) as any | null;
+  return row?.definition_json ? parseWorkflow(row.definition_json) : DEFAULT_WORKFLOW;
+}
+
+function parseWorkflow(json: string): WorkflowDefinition {
+  const workflow = JSON.parse(json);
+  return {
+    ...workflow,
+    statuses: Array.isArray(workflow.statuses) ? workflow.statuses : [],
+    actions: Array.isArray(workflow.actions) ? workflow.actions : [],
+  };
+}
+
+function isTerminal(workflow: WorkflowDefinition, status: string): boolean {
+  return Boolean(workflow.statuses.find((candidate) => candidate.id === status)?.terminal);
+}
+
+function isPresent(value: unknown): boolean {
+  return value !== undefined && value !== null && value !== "";
+}

package/index.js

@@ -1 +0,0 @@
-module.exports = {};