@flowdrop/flowdrop 1.14.0 → 2.0.0-beta.1

package/dist/adapters/agentspec/AgentSpecAdapter.js

@@ -13,7 +13,7 @@ import { getComponentTypeDefaults, extractComponentType, AGENTSPEC_NAMESPACE } f
 import { computeAutoLayout } from './autoLayout.js';
 import { v4 as uuidv4 } from 'uuid';
 import { logger } from '../../utils/logger.js';
-import { buildHandleId, extractPortId, extractDirection } from '../../utils/handleIds.js';
+import { buildHandleId, extractPortId } from '../../utils/handleIds.js';
 // ============================================================================
 // Property ↔ Port Conversion
 // ============================================================================
@@ -138,7 +138,7 @@ export class AgentSpecAdapter {
             }
         }
         // Find start node
-        const startNodeName = this.findStartNodeName(agentSpecNodes, nodeIdToName);
+        const startNodeName = this.findStartNodeName(agentSpecNodes);
         return {
             component_type: 'flow',
             name: workflow.name,
@@ -149,7 +149,7 @@ export class AgentSpecAdapter {
             data_flow_connections: dataFlowEdges.length > 0 ? dataFlowEdges : null,
             metadata: {
                 'flowdrop:workflow_id': workflow.id,
-                'flowdrop:version': workflow.metadata?.version,
+                'flowdrop:version': workflow.metadata?.schemaVersion,
                 ...(workflow.metadata?.author ? { 'flowdrop:author': workflow.metadata.author } : {}),
                 ...(workflow.metadata?.tags ? { 'flowdrop:tags': workflow.metadata.tags } : {})
             }
@@ -196,7 +196,7 @@ export class AgentSpecAdapter {
         const edges = [];
         // Control-flow edges → trigger port connections
         for (const cfEdge of agentSpecFlow.control_flow_connections) {
-            const edge = this.convertFromControlFlowEdge(cfEdge, nameToNodeId, nodes);
+            const edge = this.convertFromControlFlowEdge(cfEdge, nameToNodeId);
             if (edge)
                 edges.push(edge);
         }
@@ -215,7 +215,7 @@ export class AgentSpecAdapter {
             nodes,
             edges,
             metadata: {
-                version: agentSpecFlow.metadata?.['flowdrop:version'] || '1.0.0',
+                schemaVersion: agentSpecFlow.metadata?.['flowdrop:version'] || '1.0.0',
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
                 author: agentSpecFlow.metadata?.['flowdrop:author'],
@@ -578,7 +578,7 @@ export class AgentSpecAdapter {
     /**
      * Convert an Agent Spec ControlFlowEdge to a FlowDrop edge.
      */
-    convertFromControlFlowEdge(cfEdge, nameToNodeId, nodes) {
+    convertFromControlFlowEdge(cfEdge, nameToNodeId) {
         const sourceId = nameToNodeId.get(cfEdge.from_node);
         const targetId = nameToNodeId.get(cfEdge.to_node);
         if (!sourceId || !targetId)
@@ -615,7 +615,7 @@ export class AgentSpecAdapter {
     /**
      * Find the start node name from converted Agent Spec nodes.
      */
-    findStartNodeName(nodes, nodeIdToName) {
+    findStartNodeName(nodes) {
         // Look for an explicit start_node
         const startNode = nodes.find((n) => n.component_type === 'start_node');
         if (startNode)

package/dist/chat/batchFeedback.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Batch retry feedback for the AI Assistant.
+ *
+ * When a batch of DSL commands finishes with failures — some couldn't be
+ * parsed, or one failed to execute and the batch rolled back — the assistant
+ * needs concrete, specific feedback to self-correct. This module builds that
+ * message.
+ *
+ * Specificity is the point: the parse-error feedback names the offending text
+ * and the exact parser reason. The old generic "provide corrected commands"
+ * ask is what made auto-retry on parse errors loop on the same malformed shape
+ * — so it was disabled. Pinpointing the failure makes re-enabling it safe.
+ *
+ * @module chat/batchFeedback
+ */
+/** A command that could not be parsed, with the reason and its raw text. */
+export interface ParseFailure {
+    raw: string;
+    error: string;
+}
+/** Summary of how a batch finished, used to build retry feedback. */
+export interface BatchOutcome {
+    /** Number of commands that executed successfully before stopping. */
+    completedCount: number;
+    /** Error from the first command that failed to execute, if any. */
+    executionError?: string;
+    /** Whether the executed commands were rolled back (atomic execution failure). */
+    rolledBack: boolean;
+    /** Commands that could not be parsed and were skipped. */
+    parseErrors: ParseFailure[];
+}
+/**
+ * Build feedback for the assistant after a batch finished with failures.
+ *
+ * Pinpoints *what* went wrong — the specific parser error and offending text
+ * for unparseable commands, and/or the execution error — so the assistant has
+ * a concrete, different target to correct.
+ */
+export declare function buildRetryFeedback(outcome: BatchOutcome): string;

package/dist/chat/batchFeedback.js

@@ -0,0 +1,51 @@
+/**
+ * Batch retry feedback for the AI Assistant.
+ *
+ * When a batch of DSL commands finishes with failures — some couldn't be
+ * parsed, or one failed to execute and the batch rolled back — the assistant
+ * needs concrete, specific feedback to self-correct. This module builds that
+ * message.
+ *
+ * Specificity is the point: the parse-error feedback names the offending text
+ * and the exact parser reason. The old generic "provide corrected commands"
+ * ask is what made auto-retry on parse errors loop on the same malformed shape
+ * — so it was disabled. Pinpointing the failure makes re-enabling it safe.
+ *
+ * @module chat/batchFeedback
+ */
+/**
+ * Build feedback for the assistant after a batch finished with failures.
+ *
+ * Pinpoints *what* went wrong — the specific parser error and offending text
+ * for unparseable commands, and/or the execution error — so the assistant has
+ * a concrete, different target to correct.
+ */
+export function buildRetryFeedback(outcome) {
+    const { completedCount, executionError, rolledBack, parseErrors } = outcome;
+    const lines = [];
+    if (executionError) {
+        lines.push(`A command failed to execute: ${executionError}`);
+        lines.push(rolledBack && completedCount > 0
+            ? `The ${completedCount} command(s) that had succeeded were rolled back, so no changes were applied.`
+            : 'No changes were applied.');
+    }
+    else if (completedCount > 0) {
+        lines.push(`${completedCount} command(s) were applied successfully.`);
+    }
+    if (parseErrors.length > 0) {
+        lines.push(`\n${parseErrors.length} command(s) could not be parsed and were skipped:`);
+        for (const pe of parseErrors) {
+            const firstLine = pe.raw.split('\n')[0];
+            const preview = pe.raw.includes('\n') ? `${firstLine} …` : firstLine;
+            lines.push(`  • ${preview}\n    reason: ${pe.error}`);
+        }
+        lines.push('\nNote: multiline values must close with """ on its own line.');
+    }
+    if (rolledBack) {
+        lines.push('\nPlease re-send the full corrected batch to achieve the original goal.');
+    }
+    else {
+        lines.push('\nThe successful changes are reflected in the current workflow state. Re-send only corrected versions of the skipped command(s).');
+    }
+    return lines.join('\n');
+}

package/dist/commands/executor.js

@@ -888,17 +888,31 @@ function executeSwapNode(command, context) {
             edges: swapResult.updatedEdges
         });
     }
+    // Name each dropped edge so the user can see exactly what was lost
+    const droppedEdgeDetails = preview.droppedEdges.map(({ edge }) => {
+        const sourcePort = extractPortId(edge.sourceHandle ?? undefined) ?? '?';
+        const targetPort = extractPortId(edge.targetHandle ?? undefined) ?? '?';
+        return `${toShortId(edge.source)}:${sourcePort} → ${toShortId(edge.target)}:${targetPort}`;
+    });
     const resultData = {
         oldNodeId: toShortId(node.id),
         newNodeId: toShortId(preview.newNodeId),
         newType: command.newTypeId,
         keptEdges: preview.keptEdges.length,
         droppedEdges: preview.droppedEdges.length,
+        droppedEdgeDetails,
         hasDataLoss: preview.hasDataLoss,
         configCarriedOver: preview.configCarriedOver,
         configReset: preview.configReset
     };
-    const droppedMsg = preview.droppedEdges.length > 0 ? ` (${preview.droppedEdges.length} edge(s) dropped)` : '';
+    // Cap the inline list — a badly mismatched swap can drop dozens of edges,
+    // and the full list is always available in resultData.droppedEdgeDetails
+    const MAX_NAMED_DROPPED_EDGES = 5;
+    const namedDropped = droppedEdgeDetails.slice(0, MAX_NAMED_DROPPED_EDGES);
+    const unnamedCount = droppedEdgeDetails.length - namedDropped.length;
+    const droppedMsg = preview.droppedEdges.length > 0
+        ? ` (${preview.droppedEdges.length} edge(s) dropped: ${namedDropped.join(', ')}${unnamedCount > 0 ? `, … and ${unnamedCount} more` : ''})`
+        : '';
     return {
         ok: true,
         message: `Swapped ${toShortId(node.id)} → ${toShortId(preview.newNodeId)} (${command.newTypeId})${droppedMsg}`,

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

@@ -4,6 +4,7 @@
  * Bridges the command system to the live Svelte stores.
  * This is the only Svelte-coupled file in commands/.
  */
+import { type FlowDropInstance } from '../stores/instanceContainer.svelte.js';
 import { type CommandContext, type UIAction } from './types.js';
 import type { NodeMetadata } from '../types/index.js';
 /**
@@ -11,6 +12,8 @@ import type { NodeMetadata } from '../types/index.js';
  *
  * @param nodeTypes - Available node type definitions
  * @param onUIAction - Optional callback for UI-side actions (open config panel, select node)
+ * @param instance - The FlowDrop instance to operate on; defaults to the
+ *   page-default instance when omitted
  * @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;
+export declare function createStoreCommandContext(nodeTypes: NodeMetadata[], onUIAction?: (action: UIAction) => void, instance?: FlowDropInstance): CommandContext | null;

package/dist/commands/storeIntegration.svelte.js

@@ -4,62 +4,67 @@
  * 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 { getDefaultInstance } from '../stores/instanceContainer.svelte.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)
+ * @param instance - The FlowDrop instance to operate on; defaults to the
+ *   page-default instance when omitted
  * @returns CommandContext connected to live stores, or null if no workflow is loaded
  */
-export function createStoreCommandContext(nodeTypes, onUIAction) {
-    const workflow = getWorkflowStore();
+export function createStoreCommandContext(nodeTypes, onUIAction, instance) {
+    const fd = instance ?? getDefaultInstance();
+    const readWorkflow = () => fd.workflow.current;
+    const actions = fd.workflow.actions;
+    const history = fd.history;
+    const workflow = readWorkflow();
     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),
+        addNode: (node) => actions.addNode(node),
+        removeNode: (nodeId) => actions.removeNode(nodeId),
+        updateNode: (nodeId, updates) => actions.updateNode(nodeId, updates),
+        addEdge: (edge) => actions.addEdge(edge),
+        removeEdge: (edgeId) => actions.removeEdge(edgeId),
+        batchUpdate: (updates) => actions.batchUpdate(updates),
         undo: () => {
-            const previousState = historyService.undo();
+            const previousState = history.undo();
             if (previousState) {
-                workflowActions.restoreFromHistory(previousState);
+                actions.restoreFromHistory(previousState);
                 return true;
             }
             return false;
         },
         redo: () => {
-            const nextState = historyService.redo();
+            const nextState = history.redo();
             if (nextState) {
-                workflowActions.restoreFromHistory(nextState);
+                actions.restoreFromHistory(nextState);
                 return true;
             }
             return false;
         },
         startTransaction: (description) => {
-            const currentWorkflow = getWorkflowStore();
+            const currentWorkflow = readWorkflow();
             if (currentWorkflow) {
-                historyService.startTransaction(currentWorkflow, description);
+                history.startTransaction(currentWorkflow, description);
             }
         },
-        commitTransaction: () => historyService.commitTransaction(),
+        commitTransaction: () => history.commitTransaction(),
         cancelTransaction: () => {
-            const snapshot = historyService.cancelTransaction();
+            const snapshot = history.cancelTransaction();
             if (snapshot) {
-                workflowActions.restoreFromHistory(snapshot);
+                actions.restoreFromHistory(snapshot);
             }
         },
         emitUIAction: onUIAction,
-        swapNode: (updates) => workflowActions.swapNode(updates)
+        swapNode: (updates) => actions.swapNode(updates)
     };
     return {
-        getWorkflow: () => getWorkflowStore(),
+        getWorkflow: () => readWorkflow(),
         nodeTypes,
         typeMap: buildTypeMap(nodeTypes),
         dispatch

package/dist/commands/types.d.ts

@@ -244,6 +244,8 @@ export interface SwapNodeResultData {
     newType: string;
     keptEdges: number;
     droppedEdges: number;
+    /** Human-readable descriptions of each dropped edge, e.g. "node.1:text → node.2:message" */
+    droppedEdgeDetails: string[];
     hasDataLoss: boolean;
     configCarriedOver: string[];
     configReset: string[];