@flowdrop/flowdrop 1.4.0 → 1.5.0

package/dist/commands/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * FlowDrop Command DSL
+ *
+ * A deterministic command language for programmatic workflow manipulation.
+ * Excludes storeIntegration.svelte.ts (Svelte-coupled, import separately).
+ *
+ * @module commands
+ */
+export type { AddNodeCommand, DeleteNodeCommand, RenameNodeCommand, SetConfigCommand, GetConfigCommand, ConnectCommand, DisconnectPortsCommand, DisconnectNodeCommand, ListNodesCommand, ListEdgesCommand, ListTypesCommand, InfoCommand, UndoCommand, RedoCommand, ConfigOpenCommand, SelectNodeCommand, HelpCommand, ClearCommand, SwapNodeCommand, MoveNodeCommand, AutoLayoutCommand, BeautifyLayoutCommand, CanvasFitViewCommand, CanvasZoomInCommand, CanvasZoomOutCommand, CanvasZoomToCommand, CanvasPanToCommand, CanvasResetViewCommand, Command, ParseResult, CommandErrorCode, AddNodeResultData, ListNodesResultData, ListEdgesResultData, ListTypesResultData, InfoResultData, GetConfigResultData, SetConfigResultData, HelpResultData, SwapNodeResultData, CommandResultData, CommandResultOk, CommandResultError, CommandResult, BatchResult, UIAction, CommandDispatch, CommandContext, } from "./types.js";
+export { buildTypeMap } from "./types.js";
+export { parseCommand } from "./parser.js";
+export { executeCommand, toShortId, toShortTypeId, resolveNode, COMMAND_HELP, } from "./executor.js";
+export { executeBatch } from "./batch.js";
+export { computeAutoPosition } from "./positioner.js";

package/dist/commands/index.js

@@ -0,0 +1,17 @@
+/**
+ * FlowDrop Command DSL
+ *
+ * A deterministic command language for programmatic workflow manipulation.
+ * Excludes storeIntegration.svelte.ts (Svelte-coupled, import separately).
+ *
+ * @module commands
+ */
+export { buildTypeMap } from "./types.js";
+// Parser
+export { parseCommand } from "./parser.js";
+// Executor
+export { executeCommand, toShortId, toShortTypeId, resolveNode, COMMAND_HELP, } from "./executor.js";
+// Batch executor
+export { executeBatch } from "./batch.js";
+// Positioner
+export { computeAutoPosition } from "./positioner.js";

package/dist/commands/parser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Command Parser
+ *
+ * Parses DSL command strings into typed Command objects using
+ * regex-based pattern matching with ordered rules (first match wins).
+ *
+ * @module commands/parser
+ */
+import type { ParseResult } from "./types.js";
+/**
+ * Parse a command string into a typed Command object.
+ *
+ * Command verbs are case-insensitive; identifiers are case-sensitive.
+ * Returns ParseResult with ok: true on success, ok: false on failure.
+ */
+export declare function parseCommand(input: string): ParseResult;

package/dist/commands/parser.js

@@ -0,0 +1,278 @@
+/**
+ * Command Parser
+ *
+ * Parses DSL command strings into typed Command objects using
+ * regex-based pattern matching with ordered rules (first match wins).
+ *
+ * @module commands/parser
+ */
+/**
+ * Parse a coordinate pair like "200,300" or "-50, 100"
+ */
+function parseCoords(x, y) {
+    return { x: Number(x), y: Number(y) };
+}
+const rules = [
+    // add <type> at <x>,<y>
+    {
+        pattern: /^add\s+(\S+)\s+at\s+(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/i,
+        parse: (m) => ({
+            type: "add_node",
+            nodeTypeId: m[1],
+            position: parseCoords(m[2], m[3]),
+        }),
+    },
+    // add <type>
+    {
+        pattern: /^add\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "add_node",
+            nodeTypeId: m[1],
+        }),
+    },
+    // delete <nodeId>
+    {
+        pattern: /^delete\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "delete_node",
+            nodeId: m[1],
+        }),
+    },
+    // rename <nodeId> <label...>
+    {
+        pattern: /^rename\s+(\S+)\s+(.+)$/i,
+        parse: (m) => ({
+            type: "rename_node",
+            nodeId: m[1],
+            label: m[2].trim(),
+        }),
+    },
+    // set <nodeId>:<key> """<multiline value>"""
+    {
+        pattern: /^set\s+(\S+?):(\S+)\s+"""([\s\S]*)"""$/,
+        parse: (m) => ({
+            type: "set_config",
+            nodeId: m[1],
+            key: m[2],
+            // trim one leading/trailing newline added by the textarea wrapper
+            value: m[3].replace(/^\n/, "").replace(/\n$/, ""),
+        }),
+    },
+    // set <nodeId>:<key> <value...>
+    {
+        pattern: /^set\s+(\S+?):(\S+)\s+(.+)$/i,
+        parse: (m) => ({
+            type: "set_config",
+            nodeId: m[1],
+            key: m[2],
+            value: m[3],
+        }),
+    },
+    // get <nodeId>:<key>
+    {
+        pattern: /^get\s+(\S+?):(\S+)$/i,
+        parse: (m) => ({
+            type: "get_config",
+            nodeId: m[1],
+            key: m[2],
+        }),
+    },
+    // info <nodeId>
+    {
+        pattern: /^info\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "info",
+            nodeId: m[1],
+        }),
+    },
+    // config <nodeId>
+    {
+        pattern: /^config\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "config_open",
+            nodeId: m[1],
+        }),
+    },
+    // select <nodeId>
+    {
+        pattern: /^select\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "select_node",
+            nodeId: m[1],
+        }),
+    },
+    // connect <nid>:<port> to <nid>:<port>
+    {
+        pattern: /^connect\s+(\S+?):(\S+)\s+to\s+(\S+?):(\S+)$/i,
+        parse: (m) => ({
+            type: "connect",
+            sourceNodeId: m[1],
+            sourcePort: m[2],
+            targetNodeId: m[3],
+            targetPort: m[4],
+        }),
+    },
+    // disconnect <nid>:<port> from <nid>:<port>
+    {
+        pattern: /^disconnect\s+(\S+?):(\S+)\s+from\s+(\S+?):(\S+)$/i,
+        parse: (m) => ({
+            type: "disconnect_ports",
+            sourceNodeId: m[1],
+            sourcePort: m[2],
+            targetNodeId: m[3],
+            targetPort: m[4],
+        }),
+    },
+    // disconnect <nodeId> (disconnect all)
+    {
+        pattern: /^disconnect\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "disconnect_node",
+            nodeId: m[1],
+        }),
+    },
+    // list nodes
+    {
+        pattern: /^list\s+nodes$/i,
+        parse: () => ({ type: "list_nodes" }),
+    },
+    // list edges
+    {
+        pattern: /^list\s+edges$/i,
+        parse: () => ({ type: "list_edges" }),
+    },
+    // list types
+    {
+        pattern: /^list\s+types$/i,
+        parse: () => ({ type: "list_types" }),
+    },
+    // undo
+    {
+        pattern: /^undo$/i,
+        parse: () => ({ type: "undo" }),
+    },
+    // redo
+    {
+        pattern: /^redo$/i,
+        parse: () => ({ type: "redo" }),
+    },
+    // help <command>
+    {
+        pattern: /^help\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "help",
+            command: m[1],
+        }),
+    },
+    // help
+    {
+        pattern: /^help$/i,
+        parse: () => ({ type: "help" }),
+    },
+    // clear
+    {
+        pattern: /^clear$/i,
+        parse: () => ({ type: "clear" }),
+    },
+    // swap <nodeId> with <type> (Phase 2)
+    {
+        pattern: /^swap\s+(\S+)\s+with\s+(\S+)$/i,
+        parse: (m) => ({
+            type: "swap_node",
+            nodeId: m[1],
+            newTypeId: m[2],
+        }),
+    },
+    // move <nodeId> to <x>,<y> (Phase 2)
+    {
+        pattern: /^move\s+(\S+)\s+to\s+(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/i,
+        parse: (m) => ({
+            type: "move_node",
+            nodeId: m[1],
+            position: parseCoords(m[2], m[3]),
+        }),
+    },
+    // layout auto [--direction horizontal|vertical] (Phase 2)
+    {
+        pattern: /^layout\s+auto\s+--direction\s+(horizontal|vertical)$/i,
+        parse: (m) => ({
+            type: "auto_layout",
+            direction: m[1].toLowerCase(),
+        }),
+    },
+    // layout auto (Phase 2)
+    {
+        pattern: /^layout\s+auto$/i,
+        parse: () => ({ type: "auto_layout" }),
+    },
+    // layout beautify — preserve relative positions, normalize spacing
+    {
+        pattern: /^layout\s+beautify$/i,
+        parse: () => ({ type: "beautify_layout" }),
+    },
+    // canvas fitview | canvas fit
+    {
+        pattern: /^canvas\s+fit(?:\s*view)?$/i,
+        parse: () => ({ type: "canvas_fit_view" }),
+    },
+    // canvas zoom in
+    {
+        pattern: /^canvas\s+zoom\s+in$/i,
+        parse: () => ({ type: "canvas_zoom_in" }),
+    },
+    // canvas zoom out
+    {
+        pattern: /^canvas\s+zoom\s+out$/i,
+        parse: () => ({ type: "canvas_zoom_out" }),
+    },
+    // canvas zoom <level>
+    {
+        pattern: /^canvas\s+zoom\s+(\d+(?:\.\d+)?)$/i,
+        parse: (m) => ({ type: "canvas_zoom_to", level: Number(m[1]) }),
+    },
+    // canvas pan <x>,<y>
+    {
+        pattern: /^canvas\s+pan\s+(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/i,
+        parse: (m) => ({
+            type: "canvas_pan_to",
+            position: parseCoords(m[1], m[2]),
+        }),
+    },
+    // canvas reset
+    {
+        pattern: /^canvas\s+reset$/i,
+        parse: () => ({ type: "canvas_reset_view" }),
+    },
+];
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Parse a command string into a typed Command object.
+ *
+ * Command verbs are case-insensitive; identifiers are case-sensitive.
+ * Returns ParseResult with ok: true on success, ok: false on failure.
+ */
+export function parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return { ok: false, error: "Empty command", input };
+    }
+    for (const rule of rules) {
+        const match = trimmed.match(rule.pattern);
+        if (match) {
+            return { ok: true, command: rule.parse(match) };
+        }
+    }
+    // Extract verb for better error message
+    const verb = trimmed.split(/\s+/)[0].toLowerCase();
+    const knownVerbs = [
+        "add", "delete", "rename", "set", "get", "info", "config",
+        "select", "connect", "disconnect", "list", "undo", "redo",
+        "help", "clear", "swap", "move", "layout", "canvas",
+    ];
+    if (knownVerbs.includes(verb)) {
+        return { ok: false, error: `Invalid syntax for '${verb}' command`, input };
+    }
+    return { ok: false, error: `Unknown command: ${verb}`, input };
+}

package/dist/commands/positioner.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Auto-positioner for command-created nodes.
+ *
+ * Computes a reasonable canvas position when no explicit coordinates are given.
+ *
+ * @module commands/positioner
+ */
+import type { WorkflowNode } from "../types/index.js";
+/**
+ * Computes an auto-position for a new node based on existing nodes.
+ *
+ * - Empty canvas: returns `{ x: 100, y: 100 }`.
+ * - Non-empty canvas: places new node 250px to the right of the rightmost node,
+ *   at the same y as the rightmost node.
+ */
+export declare function computeAutoPosition(existingNodes: Pick<WorkflowNode, "position">[]): {
+    x: number;
+    y: number;
+};

package/dist/commands/positioner.js

@@ -0,0 +1,33 @@
+/**
+ * Auto-positioner for command-created nodes.
+ *
+ * Computes a reasonable canvas position when no explicit coordinates are given.
+ *
+ * @module commands/positioner
+ */
+/** Default starting position for the first node on an empty canvas. */
+const DEFAULT_START = { x: 100, y: 100 };
+/** Horizontal gap between the rightmost existing node and a new node. */
+const HORIZONTAL_GAP = 250;
+/**
+ * Computes an auto-position for a new node based on existing nodes.
+ *
+ * - Empty canvas: returns `{ x: 100, y: 100 }`.
+ * - Non-empty canvas: places new node 250px to the right of the rightmost node,
+ *   at the same y as the rightmost node.
+ */
+export function computeAutoPosition(existingNodes) {
+    if (existingNodes.length === 0) {
+        return { ...DEFAULT_START };
+    }
+    let rightmost = existingNodes[0];
+    for (const node of existingNodes) {
+        if (node.position.x > rightmost.position.x) {
+            rightmost = node;
+        }
+    }
+    return {
+        x: rightmost.position.x + HORIZONTAL_GAP,
+        y: rightmost.position.y,
+    };
+}

package/dist/commands/storeIntegration.svelte.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Store Integration Bridge
+ *
+ * Bridges the command system to the live Svelte stores.
+ * This is the only Svelte-coupled file in commands/.
+ */
+import { type CommandContext, type UIAction } from "./types.js";
+import type { NodeMetadata } from "../types/index.js";
+/**
+ * Creates a CommandContext that bridges the command system to the live Svelte stores.
+ *
+ * @param nodeTypes - Available node type definitions
+ * @param onUIAction - Optional callback for UI-side actions (open config panel, select node)
+ * @returns CommandContext connected to live stores, or null if no workflow is loaded
+ */
+export declare function createStoreCommandContext(nodeTypes: NodeMetadata[], onUIAction?: (action: UIAction) => void): CommandContext | null;

package/dist/commands/storeIntegration.svelte.js

@@ -0,0 +1,67 @@
+/**
+ * Store Integration Bridge
+ *
+ * Bridges the command system to the live Svelte stores.
+ * This is the only Svelte-coupled file in commands/.
+ */
+import { getWorkflowStore, workflowActions, } from "../stores/workflowStore.svelte.js";
+import { historyService } from "../services/historyService.js";
+import { buildTypeMap, } from "./types.js";
+/**
+ * Creates a CommandContext that bridges the command system to the live Svelte stores.
+ *
+ * @param nodeTypes - Available node type definitions
+ * @param onUIAction - Optional callback for UI-side actions (open config panel, select node)
+ * @returns CommandContext connected to live stores, or null if no workflow is loaded
+ */
+export function createStoreCommandContext(nodeTypes, onUIAction) {
+    const workflow = getWorkflowStore();
+    if (!workflow) {
+        return null;
+    }
+    const dispatch = {
+        addNode: (node) => workflowActions.addNode(node),
+        removeNode: (nodeId) => workflowActions.removeNode(nodeId),
+        updateNode: (nodeId, updates) => workflowActions.updateNode(nodeId, updates),
+        addEdge: (edge) => workflowActions.addEdge(edge),
+        removeEdge: (edgeId) => workflowActions.removeEdge(edgeId),
+        batchUpdate: (updates) => workflowActions.batchUpdate(updates),
+        undo: () => {
+            const previousState = historyService.undo();
+            if (previousState) {
+                workflowActions.restoreFromHistory(previousState);
+                return true;
+            }
+            return false;
+        },
+        redo: () => {
+            const nextState = historyService.redo();
+            if (nextState) {
+                workflowActions.restoreFromHistory(nextState);
+                return true;
+            }
+            return false;
+        },
+        startTransaction: (description) => {
+            const currentWorkflow = getWorkflowStore();
+            if (currentWorkflow) {
+                historyService.startTransaction(currentWorkflow, description);
+            }
+        },
+        commitTransaction: () => historyService.commitTransaction(),
+        cancelTransaction: () => {
+            const snapshot = historyService.cancelTransaction();
+            if (snapshot) {
+                workflowActions.restoreFromHistory(snapshot);
+            }
+        },
+        emitUIAction: onUIAction,
+        swapNode: (updates) => workflowActions.swapNode(updates),
+    };
+    return {
+        getWorkflow: () => getWorkflowStore(),
+        nodeTypes,
+        typeMap: buildTypeMap(nodeTypes),
+        dispatch,
+    };
+}