ofiere-openclaw-plugin 4.4.1 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.4.1",
+  "version": "4.7.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 10 meta-tools with 13-action workflow mastery covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, and constellation agent architecture",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/tools.ts

@@ -311,7 +311,7 @@ async function handleListTasks(
       .from("tasks")
       .select(
         "id, title, description, status, priority, agent_id, space_id, folder_id, " +
-        "start_date, due_date, progress, tags, custom_fields, created_at, updated_at",
+        "start_date, due_date, progress, tags, custom_fields, completed_at, created_at, updated_at",
       )
       .eq("user_id", userId)
       .order("updated_at", { ascending: false });
@@ -325,16 +325,27 @@ async function handleListTasks(
     const { data, error } = await query;
     if (error) return err(error.message);
 
-    // Unpack custom_fields for readability
+    // BUG 1 fix: normalize legacy statuses to documented enum
+    const STATUS_NORMALIZE: Record<string, string> = {
+      NEW: "PENDING",
+      COMPLETED: "DONE",
+      CANCELLED: "FAILED",
+    };
+
+    // Unpack custom_fields for readability, then strip raw custom_fields (BUG 9)
     const tasks = (data || []).map((t: any) => {
       const cf = t.custom_fields || {};
+      const normalizedStatus = STATUS_NORMALIZE[t.status] || t.status;
+      const { custom_fields: _cf, ...rest } = t;
       return {
-        ...t,
+        ...rest,
+        status: normalizedStatus,
         execution_plan: cf.execution_plan || undefined,
         goals: cf.goals || undefined,
         constraints: cf.constraints || undefined,
         system_prompt: cf.system_prompt || undefined,
-        instructions: cf.instructions || t.description || undefined,
+        instructions: cf.instructions || undefined,
+        completed_at: t.completed_at || undefined,
       };
     });
 
@@ -515,14 +526,24 @@ async function handleCreateTask(
     if (cf.goals) extras.push(`${(cf.goals as any[]).length} goals`);
     if (cf.constraints) extras.push(`${(cf.constraints as any[]).length} constraints`);
     if (cf.system_prompt) extras.push("custom system prompt");
-    if (startDate) extras.push(`scheduled for ${startDate}`);
+
+    // BUG 6 fix: surface recurrence fields in create response
+    const recurrenceInfo = (params.recurrence_type && params.recurrence_type !== "none")
+      ? { recurrence_type: params.recurrence_type, recurrence_interval: (params.recurrence_interval as number) || 1 }
+      : undefined;
+
+    // BUG 7 fix: only claim scheduling when bridge actually fired
+    const didSchedule = !!(startDate && effectiveAgentId);
+    if (didSchedule) extras.push(`scheduled for ${startDate}`);
+
     const extrasStr = extras.length > 0 ? ` with ${extras.join(", ")}` : "";
 
     return ok({
       id,
       message: `Task "${params.title}" created and assigned to ${assignee || "no one"}${extrasStr}`,
       task: insertData,
-      scheduledExecution: startDate ? `Will auto-execute on ${startDate}` : undefined,
+      scheduledExecution: didSchedule ? `Will auto-execute on ${startDate}` : undefined,
+      recurrence: recurrenceInfo,
     });
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
@@ -614,16 +635,30 @@ async function handleUpdateTask(
       updates.custom_fields = mergedCf;
     }
 
+    // BUG 2+4 fix: return ALL mutable fields including custom_fields and completed_at
     const { data, error } = await supabase
       .from("tasks")
       .update(updates)
       .eq("id", params.task_id as string)
       .eq("user_id", userId)
-      .select("id, title, status, priority, agent_id, start_date, due_date, progress, updated_at")
+      .select("id, title, description, status, priority, agent_id, space_id, folder_id, start_date, due_date, progress, tags, custom_fields, completed_at, updated_at")
       .single();
 
     if (error) return err(error.message);
-    return ok({ message: `Task "${data?.title}" updated`, task: data });
+
+    // Unpack custom_fields for readability in response, strip raw (BUG 9 consistency)
+    const cf = (data as any)?.custom_fields || {};
+    const { custom_fields: _cf, ...rest } = data as any;
+    const taskResponse = {
+      ...rest,
+      execution_plan: cf.execution_plan || undefined,
+      goals: cf.goals || undefined,
+      constraints: cf.constraints || undefined,
+      system_prompt: cf.system_prompt || undefined,
+      instructions: cf.instructions || undefined,
+    };
+
+    return ok({ message: `Task "${data?.title}" updated`, task: taskResponse });
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }
@@ -851,7 +886,10 @@ function registerProjectOps(
           return ok({ folders: data || [], count: (data || []).length });
         }
         case "create_folder": {
-          if (!params.name || !params.space_id) return err("Missing required: name, space_id");
+          const missingFolder: string[] = [];
+          if (!params.name) missingFolder.push("name");
+          if (!params.space_id) missingFolder.push("space_id");
+          if (missingFolder.length > 0) return err(`Missing required: ${missingFolder.join(", ")}`);
           const { data, error } = await supabase.from("pm_folders").insert({
             user_id: userId,
             space_id: params.space_id,
@@ -956,7 +994,7 @@ function registerScheduleOps(
         recurrence_type: { type: "string", enum: ["none", "hourly", "daily", "weekly", "monthly"] },
         recurrence_interval: { type: "number", description: "Repeat every N periods" },
         color: { type: "string", description: "Hex color" },
-        priority: { type: "number", description: "0-3" },
+        priority: { type: ["number", "string"], description: "0-3 (numeric) or 'low'/'medium'/'high'/'critical' (string)" },
         status: { type: "string", enum: ["scheduled", "completed", "cancelled"] },
       },
     },
@@ -979,6 +1017,21 @@ function registerScheduleOps(
           const priorityMap: Record<string, number> = { low: 0, medium: 1, high: 2, critical: 3 };
           const pVal = typeof params.priority === "number" ? params.priority
             : priorityMap[String(params.priority || "").toLowerCase()] ?? 0;
+
+          // Compute next_run_at from scheduled_date + scheduled_time
+          let nextRunAt: number | null = null;
+          try {
+            const dateStr = params.scheduled_date as string;
+            const timeStr = (params.scheduled_time as string) || "09:00";
+            const dt = new Date(`${dateStr}T${timeStr}:00Z`);
+            if (!isNaN(dt.getTime())) {
+              nextRunAt = Math.floor(dt.getTime() / 1000);
+              // If in the past, bump to now + 60s
+              const nowEpoch = Math.floor(Date.now() / 1000);
+              if (nextRunAt <= nowEpoch) nextRunAt = nowEpoch + 60;
+            }
+          } catch { /* non-fatal */ }
+
           const insertData: Record<string, any> = {
             id: evtId,
             user_id: userId,
@@ -992,6 +1045,7 @@ function registerScheduleOps(
             recurrence_type: (params.recurrence_type as string) || "none",
             recurrence_interval: (params.recurrence_interval as number) || 1,
             status: "scheduled",
+            next_run_at: nextRunAt,
             run_count: 0,
             color: (params.color as string) || null,
             priority: pVal,
@@ -1007,6 +1061,36 @@ function registerScheduleOps(
                            "recurrence_type", "recurrence_interval", "status", "color", "priority", "agent_id"]) {
             if ((params as any)[f] !== undefined) upd[f] = (params as any)[f];
           }
+          // Map string priority to number if provided
+          if (upd.priority !== undefined && typeof upd.priority === "string") {
+            const pMap: Record<string, number> = { low: 0, medium: 1, high: 2, critical: 3 };
+            upd.priority = pMap[upd.priority.toLowerCase()] ?? 0;
+          }
+          // Recompute next_run_at when date/time/recurrence changes
+          const dateChanged = params.scheduled_date !== undefined || params.scheduled_time !== undefined;
+          const recurrenceChanged = params.recurrence_type !== undefined;
+          if (dateChanged || recurrenceChanged) {
+            try {
+              // Fetch current event to merge with updates
+              const { data: current } = await supabase.from("scheduler_events").select("scheduled_date, scheduled_time, status").eq("id", params.id).single();
+              const effDate = (upd.scheduled_date || current?.scheduled_date) as string;
+              const effTime = (upd.scheduled_time || current?.scheduled_time || "09:00") as string;
+              const effStatus = (upd.status || current?.status) as string;
+              if (effDate && effStatus !== "completed" && effStatus !== "cancelled") {
+                const dt = new Date(`${effDate}T${effTime}:00Z`);
+                if (!isNaN(dt.getTime())) {
+                  let nra = Math.floor(dt.getTime() / 1000);
+                  const nowEpoch = Math.floor(Date.now() / 1000);
+                  if (nra <= nowEpoch) nra = nowEpoch + 60;
+                  upd.next_run_at = nra;
+                }
+              }
+            } catch { /* non-fatal */ }
+          }
+          // Clear next_run_at on completion/cancellation
+          if (upd.status === "completed" || upd.status === "cancelled") {
+            upd.next_run_at = null;
+          }
           const { error } = await supabase.from("scheduler_events").update(upd).eq("id", params.id);
           if (error) return err(error.message);
           return ok({ message: "Event updated", ok: true });