@flowdrop/flowdrop 1.3.0 → 1.5.0

package/dist/chat/responseParser.js

@@ -0,0 +1,87 @@
+/**
+ * Response Parser for LLM Chat Interface
+ *
+ * Extracts DSL commands from LLM markdown responses by parsing
+ * fenced code blocks (```flowdrop or bare ```).
+ *
+ * @module chat/responseParser
+ */
+/**
+ * Extract DSL commands from an LLM response string.
+ *
+ * Parses fenced code blocks labeled `flowdrop` (preferred) or bare
+ * fenced code blocks (fallback). Text outside code blocks becomes
+ * the explanation. Empty lines and comment lines inside code blocks
+ * are skipped.
+ *
+ * @param llmResponse - The raw LLM response text (may contain markdown)
+ * @returns Extracted commands and explanation text
+ */
+export function extractCommands(llmResponse) {
+    const commands = [];
+    const explanationParts = [];
+    const lines = llmResponse.split("\n");
+    let inCodeBlock = false;
+    let isFlowdropBlock = false;
+    let currentExplanation = [];
+    let multilineBuffer = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Check for code block fence opening/closing
+        if (trimmed.startsWith("```")) {
+            if (!inCodeBlock) {
+                // Opening fence
+                inCodeBlock = true;
+                const lang = trimmed.slice(3).trim().toLowerCase();
+                isFlowdropBlock = lang === "flowdrop";
+                // Flush accumulated explanation text
+                if (currentExplanation.length > 0) {
+                    explanationParts.push(currentExplanation.join("\n"));
+                    currentExplanation = [];
+                }
+            }
+            else {
+                // Closing fence
+                inCodeBlock = false;
+                isFlowdropBlock = false;
+            }
+            continue;
+        }
+        if (inCodeBlock && isFlowdropBlock) {
+            // Skip empty lines and comment lines inside code blocks
+            if (trimmed === "" || trimmed.startsWith("#") || trimmed.startsWith("//")) {
+                continue;
+            }
+            // Detect opening triple-quote without a closing one on the same line —
+            // start accumulating a multiline value block
+            if (multilineBuffer !== null) {
+                // We're inside a triple-quoted value; check for closing """
+                if (trimmed === '"""' || trimmed.endsWith('"""')) {
+                    multilineBuffer.push(line);
+                    commands.push(multilineBuffer.join("\n"));
+                    multilineBuffer = null;
+                }
+                else {
+                    multilineBuffer.push(line); // preserve raw indentation inside value
+                }
+                continue;
+            }
+            const tripleOpen = trimmed.indexOf('"""');
+            if (tripleOpen !== -1 && trimmed.indexOf('"""', tripleOpen + 3) === -1) {
+                // Opening triple-quote with no closing on this line — start buffer
+                multilineBuffer = [trimmed];
+                continue;
+            }
+            commands.push(trimmed);
+        }
+        else if (!inCodeBlock) {
+            currentExplanation.push(line);
+        }
+    }
+    // Flush remaining explanation text
+    if (currentExplanation.length > 0) {
+        explanationParts.push(currentExplanation.join("\n"));
+    }
+    const explanation = explanationParts.join("\n").trim();
+    return { explanation, commands };
+}

package/dist/commands/batch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Batch Command Executor
+ *
+ * Executes multiple commands as a single atomic operation wrapped in a
+ * transaction. A single undo reverts the entire batch.
+ *
+ * @module commands/batch
+ */
+import type { Command, CommandContext, BatchResult } from "./types.js";
+/**
+ * Execute an array of commands as a single atomic transaction.
+ *
+ * - Calls dispatch.startTransaction() before the first command
+ * - Re-reads workflow via context.getWorkflow() before each command
+ * - On success of all: calls dispatch.commitTransaction()
+ * - On first error: calls dispatch.cancelTransaction() and stops
+ */
+export declare function executeBatch(commands: Command[], context: CommandContext): BatchResult;

package/dist/commands/batch.js

@@ -0,0 +1,56 @@
+/**
+ * Batch Command Executor
+ *
+ * Executes multiple commands as a single atomic operation wrapped in a
+ * transaction. A single undo reverts the entire batch.
+ *
+ * @module commands/batch
+ */
+import { executeCommand } from "./executor.js";
+/**
+ * Execute an array of commands as a single atomic transaction.
+ *
+ * - Calls dispatch.startTransaction() before the first command
+ * - Re-reads workflow via context.getWorkflow() before each command
+ * - On success of all: calls dispatch.commitTransaction()
+ * - On first error: calls dispatch.cancelTransaction() and stops
+ */
+export function executeBatch(commands, context) {
+    const totalCount = commands.length;
+    if (totalCount === 0) {
+        return {
+            ok: true,
+            results: [],
+            completedCount: 0,
+            totalCount: 0,
+        };
+    }
+    const description = totalCount === 1
+        ? `batch: 1 command`
+        : `batch: ${totalCount} commands`;
+    context.dispatch.startTransaction(description);
+    const results = [];
+    for (let i = 0; i < commands.length; i++) {
+        // Re-read workflow before each command to avoid stale state
+        // (context.getWorkflow() is live, so this ensures fresh data)
+        const result = executeCommand(commands[i], context);
+        results.push(result);
+        if (!result.ok) {
+            context.dispatch.cancelTransaction();
+            return {
+                ok: false,
+                results,
+                completedCount: i,
+                totalCount,
+                error: result.error,
+            };
+        }
+    }
+    context.dispatch.commitTransaction();
+    return {
+        ok: true,
+        results,
+        completedCount: totalCount,
+        totalCount,
+    };
+}

package/dist/commands/executor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Command Executor
+ *
+ * Executes parsed Command objects against a CommandContext,
+ * dispatching mutations to the workflow store.
+ *
+ * @module commands/executor
+ */
+import type { Command, CommandContext, CommandResult } from "./types.js";
+import type { WorkflowNode } from "../types/index.js";
+/**
+ * Convert an internal namespaced node ID to a DSL short ID.
+ * "agentspec.llm_node.1" → "llm_node.1"
+ * "llm_node.1" → "llm_node.1" (no namespace, unchanged)
+ */
+export declare function toShortId(internalId: string): string;
+/**
+ * Convert a namespaced type ID to a short type ID.
+ * "agentspec.llm_node" → "llm_node"
+ * "llm_node" → "llm_node" (no namespace, unchanged)
+ */
+export declare function toShortTypeId(typeId: string): string;
+/**
+ * Resolve a DSL short ID (e.g. "llm_node.1") to the actual workflow node.
+ * Tries direct match first, then looks for a namespaced match.
+ */
+export declare function resolveNode(shortId: string, nodes: WorkflowNode[]): WorkflowNode | undefined;
+/** All command help entries */
+export declare const COMMAND_HELP: Array<{
+    name: string;
+    syntax: string;
+    description: string;
+}>;
+/**
+ * Execute a parsed command against a workflow context.
+ */
+export declare function executeCommand(command: Command, context: CommandContext): CommandResult;