@runfusion/fusion 0.24.0 → 0.26.0

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/useGraphPositions.test.ts

@@ -1,66 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { useGraphPositions } from "../hooks/useGraphPositions";
-import * as storage from "../utils/graphPositionStorage";
-
-vi.mock("../utils/graphPositionStorage", () => ({
-  loadPositions: vi.fn(),
-  savePositions: vi.fn(),
-  clearPositions: vi.fn(),
-}));
-
-describe("useGraphPositions", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("loads saved positions on mount with project scope", () => {
-    vi.mocked(storage.loadPositions).mockReturnValue({ a: { x: 1, y: 2 } });
-
-    const { result } = renderHook(() => useGraphPositions({ projectId: "p1", visibleTaskIds: new Set(["a"]) }));
-
-    expect(storage.loadPositions).toHaveBeenCalledWith("p1");
-    expect(result.current.savedPositions).toEqual({ a: { x: 1, y: 2 } });
-  });
-
-  it("reloads positions when project id changes", () => {
-    vi.mocked(storage.loadPositions).mockReturnValueOnce({ a: { x: 1, y: 1 } }).mockReturnValueOnce({ b: { x: 2, y: 2 } });
-
-    const { result, rerender } = renderHook(
-      ({ projectId }) => useGraphPositions({ projectId, visibleTaskIds: new Set(["a", "b"]) }),
-      { initialProps: { projectId: "p1" } },
-    );
-
-    rerender({ projectId: "p2" });
-
-    expect(storage.loadPositions).toHaveBeenNthCalledWith(1, "p1");
-    expect(storage.loadPositions).toHaveBeenNthCalledWith(2, "p2");
-    expect(result.current.savedPositions).toEqual({ b: { x: 2, y: 2 } });
-  });
-
-  it("persistPositions writes scoped and filters non-visible ids", () => {
-    vi.mocked(storage.loadPositions).mockReturnValue({});
-
-    const { result } = renderHook(() => useGraphPositions({ projectId: "p1", visibleTaskIds: new Set(["a"]) }));
-
-    act(() => {
-      result.current.persistPositions({ a: { x: 1, y: 2 }, hidden: { x: 9, y: 9 } });
-    });
-
-    expect(storage.savePositions).toHaveBeenCalledWith({ a: { x: 1, y: 2 }, hidden: { x: 9, y: 9 } }, new Set(["a"]), "p1");
-    expect(result.current.savedPositions).toEqual({ a: { x: 1, y: 2 } });
-  });
-
-  it("clearSavedPositions clears storage and resets state", () => {
-    vi.mocked(storage.loadPositions).mockReturnValue({ a: { x: 1, y: 2 } });
-
-    const { result } = renderHook(() => useGraphPositions({ projectId: "p1", visibleTaskIds: new Set(["a"]) }));
-
-    act(() => {
-      result.current.clearSavedPositions();
-    });
-
-    expect(storage.clearPositions).toHaveBeenCalledWith("p1");
-    expect(result.current.savedPositions).toBeNull();
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/__tests__/useNodeDrag.test.ts

@@ -1,81 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import type React from "react";
-import { describe, expect, it, vi } from "vitest";
-import { __internal, useNodeDrag } from "../hooks/useNodeDrag";
-
-function pointerEvent(overrides: Partial<PointerEvent> = {}) {
-  const target = {
-    setPointerCapture: vi.fn(),
-    releasePointerCapture: vi.fn(),
-    hasPointerCapture: vi.fn(() => true),
-  };
-  return {
-    isPrimary: true,
-    pointerId: 1,
-    clientX: 0,
-    clientY: 0,
-    stopPropagation: vi.fn(),
-    currentTarget: target,
-    ...overrides,
-  } as unknown as React.PointerEvent<HTMLElement>;
-}
-
-describe("useNodeDrag", () => {
-  it("transitions pending to dragging and back on pointer up", () => {
-    const onPositionChange = vi.fn();
-    const onDragStateChange = vi.fn();
-    const { result } = renderHook(() =>
-      useNodeDrag({ taskId: "A", position: { x: 10, y: 10 }, scale: 1, onPositionChange, onDragStateChange }),
-    );
-
-    act(() => result.current.onPointerDown(pointerEvent({ clientX: 10, clientY: 20 })));
-    act(() => result.current.onPointerMove(pointerEvent({ clientX: 16, clientY: 26 })));
-    expect(result.current.isDragging).toBe(true);
-    expect(onPositionChange).toHaveBeenCalledWith("A", { x: 16, y: 16 });
-
-    act(() => result.current.onPointerUp(pointerEvent({ clientX: 16, clientY: 26 })));
-    expect(result.current.isDragging).toBe(false);
-    expect(onDragStateChange).toHaveBeenCalledWith(true);
-    expect(onDragStateChange).toHaveBeenCalledWith(false);
-  });
-
-  it("stays click-only below threshold", () => {
-    const onPositionChange = vi.fn();
-    const { result } = renderHook(() =>
-      useNodeDrag({ taskId: "A", position: { x: 0, y: 0 }, scale: 1, onPositionChange }),
-    );
-
-    act(() => result.current.onPointerDown(pointerEvent()));
-    act(() => result.current.onPointerMove(pointerEvent({ clientX: __internal.DRAG_THRESHOLD_PX - 1, clientY: 0 })));
-    act(() => result.current.onPointerUp(pointerEvent({ clientX: __internal.DRAG_THRESHOLD_PX - 1, clientY: 0 })));
-
-    expect(result.current.isDragging).toBe(false);
-    expect(onPositionChange).not.toHaveBeenCalled();
-  });
-
-  it("divides pointer delta by zoom scale", () => {
-    const onPositionChange = vi.fn();
-    const { result } = renderHook(() =>
-      useNodeDrag({ taskId: "A", position: { x: 0, y: 0 }, scale: 2, onPositionChange }),
-    );
-
-    act(() => result.current.onPointerDown(pointerEvent()));
-    act(() => result.current.onPointerMove(pointerEvent({ clientX: 10, clientY: 6 })));
-
-    expect(onPositionChange).toHaveBeenCalledWith("A", { x: 5, y: 3 });
-  });
-
-  it("cancels drag cleanly on pointer cancel", () => {
-    const onPositionChange = vi.fn();
-    const { result } = renderHook(() =>
-      useNodeDrag({ taskId: "A", position: { x: 0, y: 0 }, scale: 1, onPositionChange }),
-    );
-
-    act(() => result.current.onPointerDown(pointerEvent()));
-    act(() => result.current.onPointerMove(pointerEvent({ clientX: 8, clientY: 0 })));
-    expect(result.current.isDragging).toBe(true);
-
-    act(() => result.current.onPointerCancel(pointerEvent({ clientX: 8, clientY: 0 })));
-    expect(result.current.isDragging).toBe(false);
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/dashboard-interop.d.ts

@@ -1,35 +0,0 @@
-declare module "@fusion/dashboard/app/utils/taskStuck" {
-  import type { Task } from "@fusion/core";
-
-  export function isTaskStuck(task: Task, taskStuckTimeoutMs?: number, lastFetchTimeMs?: number): boolean;
-}
-
-declare module "@fusion/dashboard/app/components/TaskCard" {
-  import type { Column, Task, TaskDetail } from "@fusion/core";
-  import type { ReactElement } from "react";
-
-  interface TaskCardProps {
-    task: Task;
-    projectId?: string;
-    onOpenDetail: (task: Task | TaskDetail) => void;
-    addToast: (message: string, type?: "success" | "error" | "info" | "warning") => void;
-    globalPaused?: boolean;
-    onUpdateTask?: (
-      id: string,
-      updates: { title?: string; description?: string; dependencies?: string[] }
-    ) => Promise<Task>;
-    onArchiveTask?: (id: string) => Promise<Task>;
-    onUnarchiveTask?: (id: string) => Promise<Task>;
-    onDeleteTask?: (id: string, options?: { removeDependencyReferences?: boolean }) => Promise<Task>;
-    onRetryTask?: (id: string) => Promise<Task>;
-    onOpenDetailWithTab?: (task: Task | TaskDetail, initialTab: "changes") => void;
-    taskStuckTimeoutMs?: number;
-    onOpenMission?: (missionId: string) => void;
-    onMoveTask?: (id: string, column: Column, optionsOrPosition?: { preserveProgress?: boolean } | number) => Promise<Task>;
-    lastFetchTimeMs?: number;
-    workflowStepNameLookup?: ReadonlyMap<string, string>;
-    disableDrag?: boolean;
-  }
-
-  export function TaskCard(props: TaskCardProps): ReactElement;
-}

package/dist/plugins/fusion-plugin-dependency-graph/src/dashboard-view.tsx

@@ -1,19 +0,0 @@
-import type { Task, TaskDetail, WorkflowStep } from "@fusion/core";
-import type { PluginDashboardViewContext } from "@fusion/dashboard/app/plugins/types";
-import { createElement } from "react";
-import { DependencyGraph } from "./DependencyGraph";
-
-function createWorkflowStepNameLookup(workflowSteps: WorkflowStep[] | undefined): ReadonlyMap<string, string> {
-  return new Map((workflowSteps ?? []).map((step) => [step.id, step.name] as const));
-}
-
-export function DependencyGraphDashboardView({ context }: { context?: PluginDashboardViewContext }) {
-  return createElement(DependencyGraph, {
-    tasks: context?.tasks ?? [],
-    projectId: context?.projectId,
-    workflowStepNameLookup: createWorkflowStepNameLookup(context?.workflowSteps),
-    onOpenDetail: context?.openTaskDetail as ((task: Task | TaskDetail) => void) | undefined,
-  });
-}
-
-export { DependencyGraph };

package/dist/plugins/fusion-plugin-dependency-graph/src/edges.tsx

@@ -1,70 +0,0 @@
-import type { GraphEdge, GraphPosition } from "./types";
-import "./GraphHighlight.css";
-
-interface GraphEdgesProps {
-  edges: GraphEdge[];
-  positions: Map<string, GraphPosition>;
-  nodeWidth?: number;
-  nodeHeight?: number;
-  highlightedEdgeIds?: Set<string>;
-}
-
-const DEFAULT_NODE_WIDTH = 280;
-const DEFAULT_NODE_HEIGHT = 100;
-
-export function GraphEdges({
-  edges,
-  positions,
-  nodeWidth = DEFAULT_NODE_WIDTH,
-  nodeHeight = DEFAULT_NODE_HEIGHT,
-  highlightedEdgeIds,
-}: GraphEdgesProps) {
-  const hasHighlights = Boolean(highlightedEdgeIds && highlightedEdgeIds.size > 0);
-
-  return (
-    <svg className="dependency-graph-edges" aria-hidden="true">
-      <defs>
-        <marker
-          id="dependency-graph-arrowhead"
-          markerWidth="10"
-          markerHeight="7"
-          refX="10"
-          refY="3.5"
-          orient="auto"
-          markerUnits="strokeWidth"
-        >
-          <path d="M 0 0 L 10 3.5 L 0 7 z" fill="var(--border)" />
-        </marker>
-      </defs>
-      {edges.map((edge) => {
-        const source = positions.get(edge.source);
-        const target = positions.get(edge.target);
-        if (!source || !target) return null;
-
-        const edgeId = `${edge.source}->${edge.target}`;
-        const isActiveHighlight = hasHighlights && (highlightedEdgeIds?.has(edgeId) ?? false);
-        const x1 = source.x + nodeWidth / 2;
-        const y1 = source.y + nodeHeight;
-        const x2 = target.x + nodeWidth / 2;
-        const y2 = target.y;
-        const controlY = y1 + (y2 - y1) / 2;
-
-        return (
-          <path
-            key={edgeId}
-            data-testid="dependency-edge"
-            data-edge-id={edgeId}
-            className={`dependency-graph-edge${isActiveHighlight ? " graph-edge--highlighted" : ""}${hasHighlights && !isActiveHighlight ? " graph-edge--dimmed" : ""}`}
-            d={`M ${x1} ${y1} C ${x1} ${controlY}, ${x2} ${controlY}, ${x2} ${y2}`}
-            fill="none"
-            stroke={isActiveHighlight ? "var(--todo)" : "var(--border)"}
-            strokeWidth={isActiveHighlight ? "var(--space-xs)" : "var(--btn-border-width)"}
-            opacity={hasHighlights && !isActiveHighlight ? 0.15 : 1}
-            markerEnd="url(#dependency-graph-arrowhead)"
-            style={{ transition: "opacity var(--transition-fast), stroke var(--transition-fast), stroke-width var(--transition-fast)" }}
-          />
-        );
-      })}
-    </svg>
-  );
-}

package/dist/plugins/fusion-plugin-dependency-graph/src/filters.ts

@@ -1,8 +0,0 @@
-import type { Column, Task } from "@fusion/core";
-
-export const INCLUDED_COLUMNS: ReadonlySet<Column> = new Set(["triage", "todo", "in-progress", "in-review"]);
-export const EXCLUDED_COLUMNS: ReadonlySet<Column> = new Set(["done", "archived"]);
-
-export function filterGraphTasks(tasks: Task[]): Task[] {
-  return tasks.filter((task) => INCLUDED_COLUMNS.has(task.column));
-}

package/dist/plugins/fusion-plugin-dependency-graph/src/hooks/__tests__/useDependencyChain.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { renderHook } from "@testing-library/react";
-import type { Task } from "@fusion/core";
-import { useDependencyChain } from "../useDependencyChain";
-
-function createTask(id: string, dependencies: string[] = []): Task {
-  return {
-    id,
-    description: id,
-    column: "todo",
-    dependencies,
-    steps: [],
-    currentStep: 0,
-    log: [],
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-  } as Task;
-}
-
-describe("useDependencyChain", () => {
-  it("returns empty set for unknown task in empty list", () => {
-    const { result } = renderHook(() => useDependencyChain([]));
-    expect(result.current.getChain("A").size).toBe(0);
-  });
-
-  it("returns single task when no dependencies", () => {
-    const { result } = renderHook(() => useDependencyChain([createTask("A")]));
-    expect(result.current.getChain("A")).toEqual(new Set(["A"]));
-  });
-
-  it("returns full linear chain", () => {
-    const tasks = [createTask("A"), createTask("B", ["A"]), createTask("C", ["B"]), createTask("D")];
-    const { result } = renderHook(() => useDependencyChain(tasks));
-    expect(result.current.getChain("C")).toEqual(new Set(["A", "B", "C"]));
-  });
-
-  it("returns full diamond chain", () => {
-    const tasks = [createTask("A"), createTask("B", ["A"]), createTask("C", ["A"]), createTask("D", ["B", "C"]), createTask("E")];
-    const { result } = renderHook(() => useDependencyChain(tasks));
-    expect(result.current.getChain("D")).toEqual(new Set(["A", "B", "C", "D"]));
-  });
-
-  it("does not include disconnected tasks", () => {
-    const { result } = renderHook(() => useDependencyChain([createTask("A"), createTask("B")]));
-    expect(result.current.getChain("A")).toEqual(new Set(["A"]));
-  });
-
-  it("handles circular dependencies safely", () => {
-    const tasks = [createTask("A", ["B"]), createTask("B", ["A"]), createTask("C")];
-    const { result } = renderHook(() => useDependencyChain(tasks));
-    expect(result.current.getChain("A")).toEqual(new Set(["A", "B"]));
-  });
-});

package/dist/plugins/fusion-plugin-dependency-graph/src/hooks/useDependencyChain.ts

@@ -1,60 +0,0 @@
-import { useCallback, useMemo } from "react";
-import type { Task } from "@fusion/core";
-
-export function useDependencyChain(tasks: Task[]) {
-  const { upstreamMap, downstreamMap } = useMemo(() => {
-    const upstream = new Map<string, Set<string>>();
-    const downstream = new Map<string, Set<string>>();
-
-    for (const task of tasks) {
-      upstream.set(task.id, new Set(task.dependencies ?? []));
-      if (!downstream.has(task.id)) downstream.set(task.id, new Set());
-    }
-
-    for (const task of tasks) {
-      for (const dependencyId of task.dependencies ?? []) {
-        if (!downstream.has(dependencyId)) downstream.set(dependencyId, new Set());
-        downstream.get(dependencyId)?.add(task.id);
-      }
-    }
-
-    return { upstreamMap: upstream, downstreamMap: downstream };
-  }, [tasks]);
-
-  const getChain = useCallback(
-    (taskId: string): Set<string> => {
-      if (!upstreamMap.has(taskId) && !downstreamMap.has(taskId)) {
-        return new Set();
-      }
-
-      const chain = new Set<string>([taskId]);
-
-      const visit = (origin: string, adjacency: Map<string, Set<string>>) => {
-        const queue = [origin];
-        const visited = new Set<string>([origin]);
-
-        while (queue.length > 0) {
-          const current = queue.shift();
-          if (!current) continue;
-          const neighbors = adjacency.get(current);
-          if (!neighbors) continue;
-
-          for (const neighbor of neighbors) {
-            if (visited.has(neighbor)) continue;
-            visited.add(neighbor);
-            chain.add(neighbor);
-            queue.push(neighbor);
-          }
-        }
-      };
-
-      visit(taskId, upstreamMap);
-      visit(taskId, downstreamMap);
-
-      return chain;
-    },
-    [downstreamMap, upstreamMap],
-  );
-
-  return { getChain };
-}

package/dist/plugins/fusion-plugin-dependency-graph/src/hooks/useGraphPositions.ts

@@ -1,45 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { clearPositions, loadPositions, savePositions, type NodePositions } from "../utils/graphPositionStorage";
-
-function filterVisiblePositions(positions: NodePositions, visibleTaskIds: Set<string>): NodePositions {
-  const filtered: NodePositions = {};
-  for (const [taskId, position] of Object.entries(positions)) {
-    if (visibleTaskIds.has(taskId)) {
-      filtered[taskId] = position;
-    }
-  }
-  return filtered;
-}
-
-export function useGraphPositions({
-  projectId,
-  visibleTaskIds,
-}: {
-  projectId: string | undefined;
-  visibleTaskIds: Set<string>;
-}): {
-  savedPositions: NodePositions | null;
-  persistPositions: (positions: NodePositions) => void;
-  clearSavedPositions: () => void;
-} {
-  const [savedPositions, setSavedPositions] = useState<NodePositions | null>(null);
-
-  useEffect(() => {
-    setSavedPositions(loadPositions(projectId));
-  }, [projectId]);
-
-  const persistPositions = useCallback(
-    (positions: NodePositions) => {
-      savePositions(positions, visibleTaskIds, projectId);
-      setSavedPositions(filterVisiblePositions(positions, visibleTaskIds));
-    },
-    [projectId, visibleTaskIds],
-  );
-
-  const clearSavedPositions = useCallback(() => {
-    clearPositions(projectId);
-    setSavedPositions(null);
-  }, [projectId]);
-
-  return { savedPositions, persistPositions, clearSavedPositions };
-}

package/dist/plugins/fusion-plugin-dependency-graph/src/hooks/useNodeDrag.ts

@@ -1,114 +0,0 @@
-import { useCallback, useMemo, useRef, useState } from "react";
-import type { MouseEvent as ReactMouseEvent, PointerEvent as ReactPointerEvent } from "react";
-import type { GraphPosition } from "../types";
-
-const DRAG_THRESHOLD_PX = 4;
-
-interface UseNodeDragOptions {
-  taskId: string;
-  position: GraphPosition;
-  scale: number;
-  onPositionChange: (taskId: string, position: GraphPosition) => void;
-  onDragStateChange?: (isDragging: boolean) => void;
-  onDragEnd?: () => void;
-}
-
-interface PendingState {
-  pointerId: number;
-  startPointer: { x: number; y: number };
-  startPosition: GraphPosition;
-}
-
-export function useNodeDrag({ taskId, position, scale, onPositionChange, onDragStateChange, onDragEnd }: UseNodeDragOptions) {
-  const [isDragging, setIsDragging] = useState(false);
-  const pendingRef = useRef<PendingState | null>(null);
-  const positionRef = useRef(position);
-  const suppressClickRef = useRef(false);
-
-  positionRef.current = position;
-
-  const endDrag = useCallback((dragging: boolean) => {
-    pendingRef.current = null;
-    setIsDragging(false);
-    if (dragging) {
-      onDragStateChange?.(false);
-      onDragEnd?.();
-      suppressClickRef.current = true;
-    }
-  }, [onDragEnd, onDragStateChange]);
-
-  const onPointerDown = useCallback((event: ReactPointerEvent<HTMLElement>) => {
-    if (!event.isPrimary) return;
-    event.stopPropagation();
-    const currentTarget = event.currentTarget;
-    if (typeof currentTarget.setPointerCapture === "function") {
-      currentTarget.setPointerCapture(event.pointerId);
-    }
-    pendingRef.current = {
-      pointerId: event.pointerId,
-      startPointer: { x: event.clientX, y: event.clientY },
-      startPosition: positionRef.current,
-    };
-  }, []);
-
-  const onPointerMove = useCallback((event: ReactPointerEvent<HTMLElement>) => {
-    const pending = pendingRef.current;
-    if (!pending || pending.pointerId !== event.pointerId) return;
-    event.stopPropagation();
-
-    const deltaX = event.clientX - pending.startPointer.x;
-    const deltaY = event.clientY - pending.startPointer.y;
-    const distance = Math.hypot(deltaX, deltaY);
-
-    if (!isDragging && distance >= DRAG_THRESHOLD_PX) {
-      setIsDragging(true);
-      onDragStateChange?.(true);
-    }
-
-    if (distance < DRAG_THRESHOLD_PX) return;
-
-    const safeScale = scale > 0 ? scale : 1;
-    onPositionChange(taskId, {
-      x: pending.startPosition.x + deltaX / safeScale,
-      y: pending.startPosition.y + deltaY / safeScale,
-    });
-  }, [isDragging, onDragStateChange, onPositionChange, scale, taskId]);
-
-  const onPointerUp = useCallback((event: ReactPointerEvent<HTMLElement>) => {
-    const pending = pendingRef.current;
-    if (!pending || pending.pointerId !== event.pointerId) return;
-    event.stopPropagation();
-    if (typeof event.currentTarget.hasPointerCapture === "function" && event.currentTarget.hasPointerCapture(event.pointerId) && typeof event.currentTarget.releasePointerCapture === "function") {
-      event.currentTarget.releasePointerCapture(event.pointerId);
-    }
-    endDrag(isDragging);
-  }, [endDrag, isDragging]);
-
-  const onPointerCancel = useCallback((event: ReactPointerEvent<HTMLElement>) => {
-    const pending = pendingRef.current;
-    if (!pending || pending.pointerId !== event.pointerId) return;
-    event.stopPropagation();
-    if (typeof event.currentTarget.hasPointerCapture === "function" && event.currentTarget.hasPointerCapture(event.pointerId) && typeof event.currentTarget.releasePointerCapture === "function") {
-      event.currentTarget.releasePointerCapture(event.pointerId);
-    }
-    endDrag(isDragging);
-  }, [endDrag, isDragging]);
-
-  const onClickCapture = useCallback((event: ReactMouseEvent<HTMLElement>) => {
-    if (!suppressClickRef.current) return;
-    suppressClickRef.current = false;
-    event.preventDefault();
-    event.stopPropagation();
-  }, []);
-
-  return useMemo(() => ({
-    isDragging,
-    onPointerDown,
-    onPointerMove,
-    onPointerUp,
-    onPointerCancel,
-    onClickCapture,
-  }), [isDragging, onClickCapture, onPointerCancel, onPointerDown, onPointerMove, onPointerUp]);
-}
-
-export const __internal = { DRAG_THRESHOLD_PX };

package/dist/plugins/fusion-plugin-dependency-graph/src/index.ts

@@ -1,24 +0,0 @@
-import { definePlugin } from "@fusion/plugin-sdk";
-
-const plugin = definePlugin({
-  manifest: {
-    id: "fusion-plugin-dependency-graph",
-    name: "Dependency Graph",
-    version: "0.1.0",
-    description: "Top-level dependency graph dashboard view",
-  },
-  state: "installed",
-  hooks: {},
-  dashboardViews: [
-    {
-      viewId: "graph",
-      label: "Graph",
-      componentPath: "./dashboard-view",
-      icon: "Network",
-      placement: "more",
-      order: 40,
-    },
-  ],
-});
-
-export default plugin;

package/dist/plugins/fusion-plugin-dependency-graph/src/layout.ts

@@ -1,91 +0,0 @@
-import type { GraphData, GraphPosition } from "./types";
-
-export interface LayoutOptions {
-  nodeWidth?: number;
-  nodeHeight?: number;
-  horizontalGap?: number;
-  verticalGap?: number;
-}
-
-const DEFAULT_LAYOUT_OPTIONS: Required<LayoutOptions> = {
-  nodeWidth: 280,
-  nodeHeight: 100,
-  horizontalGap: 40,
-  verticalGap: 80,
-};
-
-export function computeAutoLayout(
-  graphData: GraphData,
-  options?: LayoutOptions,
-): Map<string, GraphPosition> {
-  const settings = { ...DEFAULT_LAYOUT_OPTIONS, ...options };
-  const nodeIds = graphData.nodes.map((node) => node.task.id);
-  if (nodeIds.length === 0) return new Map();
-
-  const dependentsByDependency = new Map<string, string[]>();
-  const inDegree = new Map<string, number>();
-
-  for (const id of nodeIds) {
-    inDegree.set(id, 0);
-    dependentsByDependency.set(id, []);
-  }
-
-  for (const edge of graphData.edges) {
-    if (!inDegree.has(edge.source) || !inDegree.has(edge.target)) continue;
-    dependentsByDependency.get(edge.target)?.push(edge.source);
-    inDegree.set(edge.source, (inDegree.get(edge.source) ?? 0) + 1);
-  }
-
-  const queue = nodeIds.filter((id) => (inDegree.get(id) ?? 0) === 0);
-  const topologicalOrder: string[] = [];
-
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    topologicalOrder.push(current);
-    for (const dependent of dependentsByDependency.get(current) ?? []) {
-      const nextInDegree = (inDegree.get(dependent) ?? 0) - 1;
-      inDegree.set(dependent, nextInDegree);
-      if (nextInDegree === 0) queue.push(dependent);
-    }
-  }
-
-  for (const id of nodeIds) {
-    if (!topologicalOrder.includes(id)) topologicalOrder.push(id);
-  }
-
-  const depthByNode = new Map<string, number>();
-  for (const id of topologicalOrder) {
-    const parents = graphData.edges.filter((edge) => edge.source === id).map((edge) => edge.target);
-    let depth = 0;
-    for (const parent of parents) {
-      depth = Math.max(depth, (depthByNode.get(parent) ?? 0) + 1);
-    }
-    depthByNode.set(id, depth);
-  }
-
-  const layers = new Map<number, string[]>();
-  for (const id of nodeIds) {
-    const depth = depthByNode.get(id) ?? 0;
-    const layer = layers.get(depth) ?? [];
-    layer.push(id);
-    layers.set(depth, layer);
-  }
-
-  const positions = new Map<string, GraphPosition>();
-  const sortedDepths = Array.from(layers.keys()).sort((a, b) => a - b);
-
-  for (const depth of sortedDepths) {
-    const layer = layers.get(depth) ?? [];
-    layer.sort();
-    const layerWidth = layer.length * settings.nodeWidth + Math.max(0, layer.length - 1) * settings.horizontalGap;
-    const startX = -layerWidth / 2;
-
-    layer.forEach((id, index) => {
-      const x = startX + index * (settings.nodeWidth + settings.horizontalGap);
-      const y = depth * (settings.nodeHeight + settings.verticalGap);
-      positions.set(id, { x, y });
-    });
-  }
-
-  return positions;
-}