@synergenius/flow-weaver-pack-weaver 0.9.80 → 0.9.82

package/dist/ui/task-detail-view.js

@@ -383,7 +383,7 @@ function SubtaskRowItem({ sub, onBack }) {
     }, `#${sub.attempt}`)
   );
 }
-function TaskDetailView({ taskId, onBack }) {
+function TaskDetailView({ taskId, onBack, onEdit }) {
   const ctx = usePackWorkspace();
   const { callTool } = ctx;
   const packId = ctx.packId;
@@ -660,25 +660,36 @@ function TaskDetailView({ taskId, onBack }) {
         variant: "column-stretch-start-nowrap-6",
         style: { ...headerStyle, padding: "12px 16px", borderBottom: "1px solid var(--color-border-default)" }
       },
-      // Top row: back + title + status
+      // Top row: back + title + status + edit
       React2.createElement(
         Flex,
-        { variant: "row-center-start-nowrap-8" },
-        React2.createElement(IconButton, {
-          icon: "back",
+        { variant: "row-center-space-between-nowrap-8" },
+        React2.createElement(
+          Flex,
+          { variant: "row-center-start-nowrap-8", style: { flex: 1, minWidth: 0 } },
+          React2.createElement(IconButton, {
+            icon: "back",
+            size: "xs",
+            variant: "clear",
+            onClick: onBack
+          }),
+          React2.createElement(StatusIcon, {
+            status: statusToIcon[task.status] || "pending",
+            size: "sm"
+          }),
+          React2.createElement(Typography, {
+            variant: "caption-thick",
+            color: "color-text-high",
+            style: { flex: 1, minWidth: 0, wordBreak: "break-word" }
+          }, task.title || "Untitled Task")
+        ),
+        onEdit && React2.createElement(IconButton, {
+          icon: "edit",
           size: "xs",
           variant: "clear",
-          onClick: onBack
-        }),
-        React2.createElement(StatusIcon, {
-          status: statusToIcon[task.status] || "pending",
-          size: "sm"
-        }),
-        React2.createElement(Typography, {
-          variant: "caption-thick",
-          color: "color-text-high",
-          style: { flex: 1, minWidth: 0, wordBreak: "break-word" }
-        }, task.title || "Untitled Task")
+          onClick: () => onEdit(taskId),
+          title: "Edit task"
+        })
       ),
       // Meta row: status tag, assigned profile, priority, attempts
       React2.createElement(

package/dist/ui/task-editor.js

@@ -0,0 +1,613 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ui/task-editor.tsx
+var task_editor_exports = {};
+__export(task_editor_exports, {
+  TaskEditor: () => TaskEditor,
+  default: () => task_editor_default
+});
+module.exports = __toCommonJS(task_editor_exports);
+var React = require("react");
+var { useState, useEffect, useCallback } = React;
+var {
+  Flex,
+  Typography,
+  Input,
+  Button,
+  IconButton,
+  Tag,
+  Field,
+  toast,
+  usePackWorkspace
+} = require("@fw/plugin-ui-kit");
+var PRIORITY_OPTIONS = [
+  { id: "0", label: "0 \u2014 None" },
+  { id: "1", label: "1 \u2014 Low" },
+  { id: "2", label: "2 \u2014 Medium" },
+  { id: "3", label: "3 \u2014 High" },
+  { id: "4", label: "4 \u2014 Critical" }
+];
+var COMPLEXITY_OPTIONS = [
+  { id: "", label: "Not set" },
+  { id: "trivial", label: "Trivial" },
+  { id: "simple", label: "Simple" },
+  { id: "moderate", label: "Moderate" },
+  { id: "complex", label: "Complex" }
+];
+var STATUS_COLOR = {
+  "pending": "secondary",
+  "in-progress": "info",
+  "blocked": "caution",
+  "done": "positive",
+  "failed": "negative",
+  "cancelled": "negative"
+};
+function TaskEditor({ mode, taskId, onSave, onCancel, onDelete }) {
+  const ctx = usePackWorkspace();
+  const { callTool } = ctx;
+  const [title, setTitle] = useState("");
+  const [description, setDescription] = useState("");
+  const [priority, setPriority] = useState("0");
+  const [complexity, setComplexity] = useState("");
+  const [assignedProfile, setAssignedProfile] = useState("");
+  const [maxAttempts, setMaxAttempts] = useState("3");
+  const [budgetTokens, setBudgetTokens] = useState("");
+  const [budgetCost, setBudgetCost] = useState("");
+  const [notes, setNotes] = useState("");
+  const [files, setFiles] = useState([]);
+  const [newFile, setNewFile] = useState("");
+  const [dependsOn, setDependsOn] = useState([]);
+  const [newDep, setNewDep] = useState("");
+  const [taskData, setTaskData] = useState(null);
+  const [profiles, setProfiles] = useState([]);
+  const [loading, setLoading] = useState(mode === "edit");
+  useEffect(() => {
+    (async () => {
+      try {
+        const raw = await callTool("fw_weaver_profile_list", {});
+        const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+        if (Array.isArray(data)) {
+          setProfiles(data.map((p) => ({
+            id: p.id,
+            name: p.name || p.id
+          })));
+        }
+      } catch {
+      }
+    })();
+  }, [callTool]);
+  useEffect(() => {
+    if (mode !== "edit" || !taskId) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const raw = await callTool("fw_weaver_task_get", { id: taskId });
+        if (cancelled) return;
+        const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+        const t = data?.task ?? data;
+        if (!t || !t.id) {
+          toast("Task not found", { type: "error" });
+          onCancel();
+          return;
+        }
+        setTaskData(t);
+        setTitle(t.title || "");
+        setDescription(t.description || "");
+        setPriority(String(t.priority ?? 0));
+        setComplexity(t.complexity || "");
+        setAssignedProfile(t.assignedProfile || "");
+        setMaxAttempts(String(t.maxAttempts ?? 3));
+        setBudgetTokens(t.budgetTokens != null ? String(t.budgetTokens) : "");
+        setBudgetCost(t.budgetCost != null ? String(t.budgetCost) : "");
+        setNotes(t.context?.notes || "");
+        setFiles(t.context?.files || []);
+        setDependsOn(t.dependsOn || []);
+      } catch {
+        toast("Failed to load task", { type: "error" });
+        onCancel();
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [mode, taskId, callTool, onCancel]);
+  const handleAddFile = useCallback(() => {
+    const trimmed = newFile.trim();
+    if (!trimmed) return;
+    setFiles((prev) => [...prev, trimmed]);
+    setNewFile("");
+  }, [newFile]);
+  const handleRemoveFile = useCallback((index) => {
+    setFiles((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const handleAddDep = useCallback(() => {
+    const trimmed = newDep.trim();
+    if (!trimmed) return;
+    setDependsOn((prev) => [...prev, trimmed]);
+    setNewDep("");
+  }, [newDep]);
+  const handleRemoveDep = useCallback((index) => {
+    setDependsOn((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const handleSave = useCallback(async () => {
+    if (!title.trim()) {
+      toast("Title is required", { type: "error" });
+      return;
+    }
+    try {
+      if (mode === "create") {
+        const args = {
+          title: title.trim(),
+          description: description.trim(),
+          priority: parseInt(priority, 10) || 0,
+          maxAttempts: parseInt(maxAttempts, 10) || 3
+        };
+        if (complexity) args.complexity = complexity;
+        if (assignedProfile) args.assignedProfile = assignedProfile;
+        if (budgetTokens) args.budgetTokens = parseInt(budgetTokens, 10);
+        if (budgetCost) args.budgetCost = parseFloat(budgetCost);
+        if (dependsOn.length > 0) args.dependsOn = dependsOn;
+        await callTool("fw_weaver_task_create", args);
+        toast("Task created", { type: "success" });
+        if (notes.trim() || files.length > 0) {
+          try {
+          } catch {
+          }
+        }
+      } else {
+        const patch = {
+          id: taskId,
+          title: title.trim(),
+          description: description.trim(),
+          priority: parseInt(priority, 10) || 0,
+          maxAttempts: parseInt(maxAttempts, 10) || 3,
+          complexity: complexity || void 0,
+          assignedProfile: assignedProfile || null
+        };
+        if (budgetTokens) {
+          patch.budgetTokens = parseInt(budgetTokens, 10);
+        } else {
+          patch.budgetTokens = void 0;
+        }
+        if (budgetCost) {
+          patch.budgetCost = parseFloat(budgetCost);
+        } else {
+          patch.budgetCost = void 0;
+        }
+        patch.context = {
+          files,
+          notes: notes.trim(),
+          runSummaries: taskData?.context?.runSummaries || [],
+          lastError: taskData?.context?.lastError
+        };
+        await callTool("fw_weaver_task_update", patch);
+        toast("Task updated", { type: "success" });
+      }
+      onSave();
+    } catch (err) {
+      toast(err instanceof Error ? err.message : `Failed to ${mode} task`, { type: "error" });
+    }
+  }, [mode, taskId, title, description, priority, complexity, assignedProfile, maxAttempts, budgetTokens, budgetCost, notes, files, dependsOn, taskData, callTool, onSave]);
+  const handleDelete = useCallback(async () => {
+    if (!taskId) return;
+    const ok = await ctx.confirm("Are you sure you want to cancel this task?", {
+      title: "Cancel Task",
+      confirmLabel: "Cancel Task",
+      state: "danger"
+    });
+    if (!ok) return;
+    try {
+      await callTool("fw_weaver_task_cancel", { id: taskId });
+      toast("Task cancelled", { type: "success" });
+      if (onDelete) onDelete();
+    } catch (err) {
+      toast(err instanceof Error ? err.message : "Failed to cancel task", { type: "error" });
+    }
+  }, [taskId, callTool, onDelete, ctx]);
+  if (loading) {
+    return React.createElement(
+      Flex,
+      {
+        variant: "column-center-center-nowrap-12",
+        style: { padding: "24px 16px" }
+      },
+      React.createElement(Typography, { variant: "caption-regular", color: "color-text-subtle" }, "Loading task...")
+    );
+  }
+  const profileOptions = [
+    { id: "", label: "Not assigned" },
+    ...profiles.map((p) => ({ id: p.id, label: p.name }))
+  ];
+  return React.createElement(
+    Flex,
+    {
+      variant: "column-stretch-start-nowrap-0",
+      style: { width: "100%", height: "100%", overflow: "hidden" }
+    },
+    // -- Header bar --
+    React.createElement(
+      Flex,
+      {
+        variant: "row-center-space-between-nowrap-8",
+        style: { padding: "8px 16px", flexShrink: 0, borderBottom: "1px solid var(--color-border-default)" }
+      },
+      React.createElement(
+        Flex,
+        { variant: "row-center-start-nowrap-8" },
+        React.createElement(IconButton, {
+          icon: "back",
+          size: "xs",
+          variant: "clear",
+          onClick: onCancel,
+          title: "Back"
+        }),
+        React.createElement(
+          Typography,
+          { variant: "caption-thick", color: "color-text-high" },
+          mode === "create" ? "Create Task" : "Edit Task"
+        )
+      ),
+      mode === "edit" && onDelete && React.createElement(IconButton, {
+        icon: "outlinedDelete",
+        size: "sm",
+        variant: "clear",
+        color: "danger",
+        onClick: handleDelete,
+        title: "Cancel task"
+      })
+    ),
+    // -- Scrollable form body --
+    React.createElement(
+      Flex,
+      {
+        variant: "column-stretch-start-nowrap-10",
+        style: { flex: 1, minHeight: 0, overflow: "auto", padding: "12px 16px" }
+      },
+      // -- Edit-only: Status tag --
+      mode === "edit" && taskData && React.createElement(
+        Field,
+        { label: "Status" },
+        React.createElement(Tag, {
+          size: "small",
+          color: STATUS_COLOR[taskData.status] || "secondary"
+        }, taskData.status)
+      ),
+      // -- Title --
+      React.createElement(
+        Field,
+        { label: "Title" },
+        React.createElement(Input, {
+          type: "text",
+          size: "small",
+          placeholder: "Task title (required)",
+          value: title,
+          onChange: (v) => setTitle(v),
+          defaultBoxStyle: { flex: 1, minWidth: 0 },
+          inputBoxStyle: { maxWidth: "none" }
+        })
+      ),
+      // -- Description --
+      React.createElement(
+        Field,
+        { label: "Description" },
+        React.createElement(Input, {
+          type: "text",
+          size: "small",
+          placeholder: "Detailed task description",
+          value: description,
+          onChange: (v) => setDescription(v),
+          defaultBoxStyle: { flex: 1, minWidth: 0 },
+          inputBoxStyle: { maxWidth: "none" }
+        })
+      ),
+      // -- Priority --
+      React.createElement(
+        Field,
+        { label: "Priority" },
+        React.createElement(Input, {
+          type: "select",
+          size: "small",
+          options: PRIORITY_OPTIONS,
+          optionId: priority,
+          onChange: (id) => setPriority(id),
+          defaultBoxStyle: { flex: 1, minWidth: 0 }
+        })
+      ),
+      // -- Complexity --
+      React.createElement(
+        Field,
+        { label: "Complexity" },
+        React.createElement(Input, {
+          type: "select",
+          size: "small",
+          options: COMPLEXITY_OPTIONS,
+          optionId: complexity,
+          onChange: (id) => setComplexity(id),
+          defaultBoxStyle: { flex: 1, minWidth: 0 }
+        })
+      ),
+      // -- Assigned Profile --
+      React.createElement(
+        Field,
+        { label: "Profile" },
+        React.createElement(Input, {
+          type: "select",
+          size: "small",
+          options: profileOptions,
+          optionId: assignedProfile,
+          onChange: (id) => setAssignedProfile(id),
+          placeholder: "Select profile",
+          defaultBoxStyle: { flex: 1, minWidth: 0 }
+        })
+      ),
+      // -- Max Attempts --
+      React.createElement(
+        Field,
+        { label: "Max Attempts" },
+        React.createElement(Input, {
+          type: "number",
+          size: "small",
+          placeholder: "3",
+          value: maxAttempts,
+          onChange: (v) => setMaxAttempts(v),
+          defaultBoxStyle: { flex: 1, minWidth: 0 },
+          inputBoxStyle: { maxWidth: "none" }
+        })
+      ),
+      // -- Budget Tokens --
+      React.createElement(
+        Field,
+        { label: "Budget Tokens" },
+        React.createElement(Input, {
+          type: "number",
+          size: "small",
+          placeholder: "Optional token limit",
+          value: budgetTokens,
+          onChange: (v) => setBudgetTokens(v),
+          defaultBoxStyle: { flex: 1, minWidth: 0 },
+          inputBoxStyle: { maxWidth: "none" }
+        })
+      ),
+      // -- Budget Cost --
+      React.createElement(
+        Field,
+        { label: "Budget Cost" },
+        React.createElement(Input, {
+          type: "number",
+          size: "small",
+          placeholder: "Optional cost limit (USD)",
+          value: budgetCost,
+          onChange: (v) => setBudgetCost(v),
+          defaultBoxStyle: { flex: 1, minWidth: 0 },
+          inputBoxStyle: { maxWidth: "none" }
+        })
+      ),
+      // -- Notes --
+      React.createElement(
+        Field,
+        { label: "Notes" },
+        React.createElement(Input, {
+          type: "text",
+          size: "small",
+          placeholder: "Optional notes for context",
+          value: notes,
+          onChange: (v) => setNotes(v),
+          defaultBoxStyle: { flex: 1, minWidth: 0 },
+          inputBoxStyle: { maxWidth: "none" }
+        })
+      ),
+      // -- Files --
+      React.createElement(
+        Field,
+        { label: "Files", align: "start" },
+        React.createElement(
+          Flex,
+          { variant: "column-stretch-start-nowrap-6" },
+          // Add file row
+          React.createElement(
+            Flex,
+            { variant: "row-center-start-nowrap-4", style: { overflow: "hidden" } },
+            React.createElement(Input, {
+              type: "text",
+              size: "small",
+              placeholder: "File path",
+              value: newFile,
+              onChange: (v) => setNewFile(v),
+              onEnter: handleAddFile,
+              defaultBoxStyle: { flex: 1, minWidth: 0 },
+              inputBoxStyle: { maxWidth: "none" }
+            }),
+            React.createElement(IconButton, {
+              icon: "add",
+              size: "sm",
+              variant: "outlined",
+              color: "primary",
+              onClick: handleAddFile,
+              disabled: !newFile.trim()
+            })
+          ),
+          ...files.map(
+            (file, idx) => React.createElement(
+              Flex,
+              {
+                key: `file-${idx}`,
+                variant: "row-center-start-nowrap-6",
+                style: { paddingLeft: "4px" }
+              },
+              React.createElement(Typography, {
+                variant: "smallCaption-regular",
+                color: "color-text-high",
+                style: { flex: 1, minWidth: 0, fontFamily: "var(--font-mono, monospace)" }
+              }, file),
+              React.createElement(IconButton, {
+                icon: "close",
+                size: "xs",
+                variant: "clear",
+                color: "danger",
+                onClick: () => handleRemoveFile(idx)
+              })
+            )
+          )
+        )
+      ),
+      // -- Dependencies --
+      React.createElement(
+        Field,
+        { label: "Dependencies", align: "start" },
+        React.createElement(
+          Flex,
+          { variant: "column-stretch-start-nowrap-6" },
+          // Add dependency row (create mode only)
+          mode === "create" && React.createElement(
+            Flex,
+            { variant: "row-center-start-nowrap-4", style: { overflow: "hidden" } },
+            React.createElement(Input, {
+              type: "text",
+              size: "small",
+              placeholder: "Task ID",
+              value: newDep,
+              onChange: (v) => setNewDep(v),
+              onEnter: handleAddDep,
+              defaultBoxStyle: { flex: 1, minWidth: 0 },
+              inputBoxStyle: { maxWidth: "none" }
+            }),
+            React.createElement(IconButton, {
+              icon: "add",
+              size: "sm",
+              variant: "outlined",
+              color: "primary",
+              onClick: handleAddDep,
+              disabled: !newDep.trim()
+            })
+          ),
+          // Dependency list
+          dependsOn.length > 0 ? React.createElement(
+            Flex,
+            { variant: "column-stretch-start-nowrap-4" },
+            ...dependsOn.map(
+              (dep, idx) => React.createElement(
+                Flex,
+                {
+                  key: `dep-${idx}`,
+                  variant: "row-center-start-nowrap-6",
+                  style: { paddingLeft: "4px" }
+                },
+                React.createElement(Typography, {
+                  variant: "smallCaption-regular",
+                  color: "color-text-high",
+                  style: { flex: 1, minWidth: 0, fontFamily: "var(--font-mono, monospace)" }
+                }, dep),
+                mode === "create" && React.createElement(IconButton, {
+                  icon: "close",
+                  size: "xs",
+                  variant: "clear",
+                  color: "danger",
+                  onClick: () => handleRemoveDep(idx)
+                })
+              )
+            )
+          ) : React.createElement(Typography, {
+            variant: "smallCaption-regular",
+            color: "color-text-subtle",
+            style: { paddingLeft: "4px" }
+          }, "None")
+        )
+      ),
+      // -- Edit-only: read-only metadata --
+      mode === "edit" && taskData && React.createElement(
+        Flex,
+        {
+          variant: "column-stretch-start-nowrap-10",
+          style: { marginTop: 8, paddingTop: 12, borderTop: "1px solid var(--color-border-default)" }
+        },
+        React.createElement(
+          Field,
+          { label: "Created by" },
+          React.createElement(
+            Typography,
+            { variant: "smallCaption-regular", color: "color-text-medium" },
+            taskData.createdBy || "unknown"
+          )
+        ),
+        React.createElement(
+          Field,
+          { label: "Created at" },
+          React.createElement(
+            Typography,
+            { variant: "smallCaption-regular", color: "color-text-medium" },
+            taskData.createdAt ? new Date(taskData.createdAt).toLocaleString() : "-"
+          )
+        ),
+        React.createElement(
+          Field,
+          { label: "Updated at" },
+          React.createElement(
+            Typography,
+            { variant: "smallCaption-regular", color: "color-text-medium" },
+            taskData.updatedAt ? new Date(taskData.updatedAt).toLocaleString() : "-"
+          )
+        ),
+        React.createElement(
+          Field,
+          { label: "Tokens used" },
+          React.createElement(
+            Typography,
+            { variant: "smallCaption-regular", color: "color-text-medium" },
+            (taskData.tokensUsed ?? 0).toLocaleString()
+          )
+        ),
+        React.createElement(
+          Field,
+          { label: "Cost used" },
+          React.createElement(
+            Typography,
+            { variant: "smallCaption-regular", color: "color-text-medium" },
+            `$${(taskData.costUsed ?? 0).toFixed(3)}`
+          )
+        ),
+        taskData.context?.lastError && React.createElement(
+          Field,
+          { label: "Last error", align: "start" },
+          React.createElement(Typography, {
+            variant: "smallCaption-regular",
+            color: "color-status-negative",
+            style: { fontFamily: "var(--font-mono, monospace)", whiteSpace: "pre-wrap" }
+          }, taskData.context.lastError)
+        )
+      ),
+      // -- Save button --
+      React.createElement(
+        Flex,
+        { variant: "row-center-end-nowrap-8", style: { paddingTop: 8 } },
+        React.createElement(Button, {
+          size: "xs",
+          variant: "fill",
+          color: "primary",
+          onClick: handleSave,
+          disabled: !title.trim()
+        }, mode === "create" ? "Create" : "Save")
+      )
+    )
+  );
+}
+var task_editor_default = TaskEditor;
+module.exports = TaskEditor;