@flowdrop/flowdrop 1.4.0 → 1.6.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,295 @@
+/**
+ * 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,
+            // then unescape \""" → """ (escape sequence for literal triple-quotes in content)
+            value: m[3].replace(/^\n|\n$/g, '').replace(/\\"""/g, '"""')
+        })
+    },
+    // 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
+    };
+}