@lhi/n8m 0.2.4 → 0.3.0

package/dist/services/ai.service.js

@@ -104,7 +104,7 @@ export class AIService {
             },
             body: JSON.stringify({
                 model,
-                max_tokens: 4096,
+                max_tokens: options.maxTokens ?? 4096,
                 messages: [{ role: 'user', content: prompt }],
                 temperature: options.temperature ?? 0.7,
             })
@@ -205,6 +205,39 @@ export class AIService {
             throw new Error(`invalid JSON returned by AI: ${cleanJson}`);
         }
     }
+    async chatAboutSpec(spec, history, userMessage) {
+        const conversationText = history
+            .map(h => `${h.role === 'user' ? 'User' : 'Architect'}: ${h.content}`)
+            .join('\n');
+        const prompt = `You are an n8n Workflow Architect having a planning conversation with the user.
+
+Current Workflow Spec:
+${JSON.stringify(spec, null, 2)}
+
+${conversationText ? `Conversation so far:\n${conversationText}\n` : ''}User: ${userMessage}
+
+Respond conversationally to help the user understand or refine the plan. If the user requests changes to the workflow approach, update the spec accordingly.
+
+Output a JSON object:
+{
+  "reply": "Your conversational response here",
+  "updatedSpec": { /* full spec JSON — same structure as input, with any requested changes applied */ }
+}
+
+Output ONLY valid JSON. No markdown.`;
+        const response = await this.generateContent(prompt);
+        const cleanJson = response.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            const result = JSON.parse(jsonrepair(cleanJson));
+            return {
+                reply: result.reply || '',
+                updatedSpec: result.updatedSpec || spec,
+            };
+        }
+        catch {
+            return { reply: response, updatedSpec: spec };
+        }
+    }
     async generateWorkflow(goal) {
         const prompt = `You are an n8n Expert.
        Generate a valid n8n workflow JSON for the following goal: "${goal}".
@@ -244,6 +277,196 @@ export class AIService {
             return { ...primarySpec, suggestedName: primarySpec.suggestedName + " (Alt)", strategyName: 'alternative' };
         }
     }
+    async generateModificationPlan(instruction, workflowJson) {
+        const nodeList = (workflowJson.nodes || [])
+            .map((n) => `${n.name} (${n.type})`)
+            .join(', ');
+        const prompt = `You are an n8n Solution Architect reviewing a workflow modification request.
+
+Workflow: "${workflowJson.name || 'Untitled'}"
+Current nodes: ${nodeList}
+
+Modification requested: "${instruction}"
+
+Analyze the request and produce a concise modification plan as a JSON object:
+{
+  "suggestedName": "Updated workflow name (or same if unchanged)",
+  "description": "One-sentence summary of what this modification achieves",
+  "proposedChanges": ["Specific change 1", "Specific change 2"],
+  "affectedNodes": ["Node names that will be added, modified, or removed"]
+}
+Output ONLY the JSON object. No commentary.`;
+        const response = await this.generateContent(prompt);
+        const cleanJson = response.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            return JSON.parse(jsonrepair(cleanJson));
+        }
+        catch {
+            return {
+                suggestedName: workflowJson.name || 'Modified Workflow',
+                description: instruction,
+                proposedChanges: [instruction],
+                affectedNodes: [],
+            };
+        }
+    }
+    async applyModification(workflowJson, userGoal, spec, userFeedback, validNodeTypes = []) {
+        const nodeService = NodeDefinitionsService.getInstance();
+        const staticRef = nodeService.getStaticReference();
+        const prompt = `You are an n8n Workflow Engineer. Modify the following existing workflow.
+
+ORIGINAL WORKFLOW:
+${JSON.stringify(workflowJson, null, 2)}
+
+MODIFICATION INSTRUCTION:
+${userGoal}
+
+MODIFICATION PLAN:
+${JSON.stringify(spec, null, 2)}
+${userFeedback ? `\nUSER FEEDBACK:\n${userFeedback}\n` : ''}
+[N8N NODE REFERENCE GUIDE]
+${staticRef}
+
+${validNodeTypes.length > 0 ? `Valid node types: ${validNodeTypes.slice(0, 100).join(', ')}` : ''}
+
+Apply ALL proposed changes. Then verify the following before outputting:
+
+CONNECTION RULES — EVERY node must appear in the connections object:
+1. Every non-trigger node must have at least one incoming connection from another node.
+2. Every node that is not a terminal/sink must have at least one outgoing connection.
+3. New nodes inserted into the middle of the flow must be wired into BOTH the incoming edge (from the predecessor) AND the outgoing edge (to the successor) — do not leave gaps in the chain.
+4. If the original workflow had error output connections (e.g. "error" branch), replicate that pattern for any new nodes that have onError: "continueErrorOutput".
+5. The connections object keys are SOURCE node names; the "node" field inside is the TARGET node name. Double-check every name matches exactly.
+
+Preserve all existing nodes, connections, credentials, and IDs not mentioned in the plan. Add new nodes with unique string IDs.
+
+Output ONLY the complete workflow JSON object. No commentary. No markdown.`;
+        const response = await this.generateContent(prompt, { maxTokens: 8192 });
+        const cleanJson = response.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            const result = JSON.parse(jsonrepair(cleanJson));
+            const modified = result.workflows?.[0] || result;
+            return this.wireOrphanedErrorHandlers(this.fixHallucinatedNodes(this.repairConnections(modified, workflowJson)));
+        }
+        catch (e) {
+            console.error('Failed to parse modified workflow JSON', e);
+            return workflowJson;
+        }
+    }
+    /**
+     * Merge connections from the original workflow into the modified one for any
+     * nodes that exist in both but lost their connections during LLM generation.
+     * Then does a position-based stitch for any remaining nodes with no outgoing
+     * main connection, using canvas x/y position to infer the intended chain order.
+     */
+    repairConnections(modified, original) {
+        if (!modified?.nodes || !modified?.connections)
+            return modified;
+        const connections = { ...(modified.connections || {}) };
+        const origConnections = original?.connections || {};
+        const nodeNames = new Set(modified.nodes.map((n) => n.name));
+        // 1. Restore original connections for nodes that exist in both but lost theirs.
+        // Operates per output-type so that nodes with partial connections (e.g. LLM
+        // generated "main" but dropped "error") still get their missing types restored.
+        for (const [srcName, srcConn] of Object.entries(origConnections)) {
+            if (!nodeNames.has(srcName))
+                continue;
+            const existingConn = connections[srcName] || {};
+            let changed = false;
+            const merged = { ...existingConn };
+            for (const [outputType, branches] of Object.entries(srcConn)) {
+                if (existingConn[outputType])
+                    continue; // this output type already present — keep LLM version
+                const filteredBranches = branches.map((branch) => branch.filter((edge) => nodeNames.has(edge.node))).filter((branch) => branch.length > 0);
+                if (filteredBranches.length > 0) {
+                    merged[outputType] = filteredBranches;
+                    changed = true;
+                }
+            }
+            if (changed)
+                connections[srcName] = merged;
+        }
+        // 2. Position-based chain stitching for nodes still missing outgoing main connections.
+        // Group nodes by approximate y-row (round to nearest 300px), sort each row by x.
+        // For any node with no outgoing main connection, wire it to the next node in its row.
+        const nodes = modified.nodes;
+        // 1b. Restore onError settings that the LLM may have stripped from nodes.
+        const origNodeMap = new Map((original?.nodes ?? []).map((n) => [n.name, n]));
+        for (const node of nodes) {
+            const orig = origNodeMap.get(node.name);
+            if (orig?.onError && !node.onError) {
+                node.onError = orig.onError;
+            }
+        }
+        // 1c. Wire error connections for any node with onError:"continueErrorOutput" that lacks one.
+        // Covers new nodes the LLM added to the flow (not present in original) — step 1 can't restore
+        // connections for those. Infer the error handler from what the original connected to.
+        const errorHandlerNodes = new Set();
+        for (const srcConn of Object.values(origConnections)) {
+            for (const branch of (srcConn.error ?? [])) {
+                for (const edge of branch) {
+                    if (nodeNames.has(edge.node))
+                        errorHandlerNodes.add(edge.node);
+                }
+            }
+        }
+        if (errorHandlerNodes.size > 0) {
+            const errorHandler = [...errorHandlerNodes][0];
+            for (const node of nodes) {
+                if (node.onError !== 'continueErrorOutput')
+                    continue;
+                if (connections[node.name]?.error?.length > 0)
+                    continue;
+                connections[node.name] = {
+                    ...(connections[node.name] || {}),
+                    error: [[{ node: errorHandler, type: 'main', index: 0 }]],
+                };
+            }
+        }
+        // 1d. Remove LLM-hallucinated main connections from nodes that were terminal in the original.
+        // A node is terminal if it existed in the original but had no outgoing main connections there.
+        const origNodeNames = new Set((original?.nodes ?? []).map((n) => n.name));
+        for (const node of nodes) {
+            if (!origNodeNames.has(node.name))
+                continue; // new node — leave LLM connections alone
+            const origConn = origConnections[node.name];
+            const hadMain = origConn?.main?.some((b) => b.length > 0);
+            if (!hadMain && connections[node.name]?.main?.length > 0) {
+                const nc = { ...(connections[node.name] || {}) };
+                delete nc.main;
+                if (Object.keys(nc).length > 0) {
+                    connections[node.name] = nc;
+                }
+                else {
+                    delete connections[node.name];
+                }
+            }
+        }
+        const rowMap = new Map();
+        for (const node of nodes) {
+            const x = node.position?.[0] ?? 0;
+            const y = node.position?.[1] ?? 0;
+            const rowKey = Math.round(y / 300) * 300;
+            if (!rowMap.has(rowKey))
+                rowMap.set(rowKey, []);
+            rowMap.get(rowKey).push({ ...node, _x: x });
+        }
+        for (const row of rowMap.values()) {
+            row.sort((a, b) => a._x - b._x);
+            for (let i = 0; i < row.length - 1; i++) {
+                const src = row[i];
+                const tgt = row[i + 1];
+                // Only stitch if this node has NO outgoing main connections yet
+                if (connections[src.name]?.main?.length > 0)
+                    continue;
+                connections[src.name] = {
+                    ...(connections[src.name] || {}),
+                    main: [[{ node: tgt.name, type: 'main', index: 0 }]],
+                };
+            }
+        }
+        return { ...modified, connections };
+    }
     async generateWorkflowFix(workflow, error, model, _stream = false, validNodeTypes = []) {
         const nodeService = NodeDefinitionsService.getInstance();
         const staticRef = nodeService.getStaticReference();
@@ -265,7 +488,8 @@ export class AIService {
         const cleanJson = response.replace(/```json\n?|\n?```/g, "").trim();
         try {
             const fixed = JSON.parse(jsonrepair(cleanJson));
-            return fixed.workflows?.[0] || fixed;
+            const result = fixed.workflows?.[0] || fixed;
+            return this.wireOrphanedErrorHandlers(this.fixHallucinatedNodes(this.repairConnections(result, workflow)));
         }
         catch (e) {
             console.error("Failed to parse fix JSON", e);
@@ -329,6 +553,60 @@ export class AIService {
         });
         return this.fixN8nConnections(workflow);
     }
+    /**
+     * Wire orphaned error-handler nodes that the LLM created but forgot to connect.
+     * Detects nodes with no incoming connections whose name suggests they are error
+     * handlers (contains "Error", "Cleanup", "Rollback", "Fallback", etc.) and wires
+     * every non-terminal, non-handler node's error output to them.
+     * Also sets onError:"continueErrorOutput" on each wired source node.
+     */
+    wireOrphanedErrorHandlers(workflow) {
+        if (!workflow?.nodes || !workflow?.connections)
+            return workflow;
+        const nodes = workflow.nodes;
+        const connections = { ...(workflow.connections || {}) };
+        // Build set of nodes that have at least one incoming connection.
+        const hasIncoming = new Set();
+        for (const srcConn of Object.values(connections)) {
+            for (const branches of Object.values(srcConn)) {
+                for (const branch of branches) {
+                    for (const edge of branch) {
+                        if (edge?.node)
+                            hasIncoming.add(edge.node);
+                    }
+                }
+            }
+        }
+        const TRIGGER_TYPES = /trigger|webhook|cron|schedule|interval|timer|poller|gmail|rss/i;
+        const ERROR_HANDLER_PATTERN = /error|cleanup|rollback|fallback|on.?fail|recover/i;
+        // Orphaned nodes = no incoming connection, not a trigger, name looks like an error handler.
+        const errorHandlers = nodes.filter(n => !hasIncoming.has(n.name) &&
+            !TRIGGER_TYPES.test(n.type || '') &&
+            ERROR_HANDLER_PATTERN.test(n.name));
+        if (errorHandlers.length === 0)
+            return workflow;
+        // Non-terminal nodes = have at least one outgoing main connection.
+        const nonTerminal = new Set();
+        for (const [srcName, srcConn] of Object.entries(connections)) {
+            const mainBranches = srcConn.main;
+            if (mainBranches?.some((b) => b.length > 0)) {
+                nonTerminal.add(srcName);
+            }
+        }
+        for (const handler of errorHandlers) {
+            const sources = nodes.filter(n => nonTerminal.has(n.name) &&
+                !ERROR_HANDLER_PATTERN.test(n.name) &&
+                !(connections[n.name]?.error?.length > 0));
+            for (const src of sources) {
+                src.onError = 'continueErrorOutput';
+                connections[src.name] = {
+                    ...(connections[src.name] || {}),
+                    error: [[{ node: handler.name, type: 'main', index: 0 }]],
+                };
+            }
+        }
+        return { ...workflow, connections };
+    }
     fixN8nConnections(workflow) {
         if (!workflow.connections || typeof workflow.connections !== 'object')
             return workflow;
@@ -447,6 +725,63 @@ Return ONLY the replacement JavaScript code. No markdown fences, no explanation.
         const response = await this.generateContent(prompt, { temperature: 0.1 });
         return response.replace(/^```(?:javascript|js)?\n?|\n?```$/g, '').trim();
     }
+    /**
+     * Analyze a validated working workflow and generate a reusable pattern file.
+     * Returns markdown content ready to save to docs/patterns/.
+     */
+    async generatePattern(workflowJson) {
+        const stripped = {
+            name: workflowJson.name,
+            nodes: (workflowJson.nodes || []).map((n) => ({
+                name: n.name,
+                type: n.type,
+                typeVersion: n.typeVersion,
+                parameters: n.parameters,
+            })),
+            connections: workflowJson.connections,
+        };
+        const prompt = `You are an n8n workflow expert analyzing a VALIDATED, WORKING n8n workflow.
+Your job is to extract the reusable knowledge from this workflow into a pattern file that will teach an AI engineer to build similar workflows correctly.
+
+Workflow JSON:
+${JSON.stringify(stripped, null, 2)}
+
+Generate a markdown pattern file with the following structure:
+
+1. First line MUST be: <!-- keywords: <comma-separated keywords> -->
+   - Keywords should cover: service names, operations, node types, integration categories
+   - Example: <!-- keywords: bigquery, google bigquery, sql, merge, staging, http request -->
+
+2. A short title: # Pattern: <descriptive title>
+
+3. ## Critical Rules
+   - List any gotchas, wrong approaches to avoid, or non-obvious choices made in this workflow
+   - Be specific: e.g. "Use n8n-nodes-base.httpRequest instead of n8n-nodes-base.googleBigQuery because..."
+   - If there are no critical rules, omit this section
+
+4. ## Authentication
+   - Document the credential type and any required scopes/permissions
+   - Only include if the workflow uses credentials
+
+5. One section per major technique demonstrated, e.g.:
+   ## <Technique Name>
+   - Explain what it does and why
+   - Include the relevant node config as a JSON code block (use actual values from the workflow, anonymize project IDs to YOUR_PROJECT etc.)
+   - Note any important parameter choices
+
+6. ## Error Handling (if the workflow has error paths)
+   - Explain the error handling strategy
+
+Keep the pattern focused and actionable. An AI reading this should be able to reproduce the technique correctly.
+Output ONLY the markdown content. No commentary before or after.`;
+        const content = await this.generateContent(prompt, { temperature: 0.3 });
+        // Derive a filename slug from the workflow name
+        const slug = (workflowJson.name || 'workflow')
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '');
+        return { content, slug };
+    }
     async evaluateCandidates(goal, candidates) {
         if (candidates.length === 0)
             return { selectedIndex: 0, reason: "No candidates" };

package/dist/services/node-definitions.service.d.ts

@@ -6,6 +6,8 @@ export interface ReducedNodeDefinition {
 }
 export declare class NodeDefinitionsService {
     private static instance;
+    /** Override candidate dirs for testing only. When set, replaces the default dir list in searchPatterns(). */
+    static _testPatternsDirs: string[] | null;
     private definitions;
     private client;
     private defaultClient;
@@ -35,6 +37,12 @@ export declare class NodeDefinitionsService {
      * We keep properties (parameters) but strip UI metadata.
      */
     private reduceDefinition;
+    /**
+     * Search pattern library for examples matching the query.
+     * Patterns are markdown files in docs/patterns/ with a keywords frontmatter line.
+     * Format: <!-- keywords: bigquery, http, google -->
+     */
+    searchPatterns(query: string): string[];
     /**
      * Format definitions for LLM System Prompt
      */

package/dist/services/node-definitions.service.js

@@ -7,6 +7,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class NodeDefinitionsService {
     static instance;
+    /** Override candidate dirs for testing only. When set, replaces the default dir list in searchPatterns(). */
+    static _testPatternsDirs = null;
     definitions = [];
     client;
     defaultClient;
@@ -137,6 +139,49 @@ export class NodeDefinitionsService {
             }))
         };
     }
+    /**
+     * Search pattern library for examples matching the query.
+     * Patterns are markdown files in docs/patterns/ with a keywords frontmatter line.
+     * Format: <!-- keywords: bigquery, http, google -->
+     */
+    searchPatterns(query) {
+        const lowerQuery = query.toLowerCase();
+        const terms = lowerQuery.split(/\s+/).filter(t => t.length > 2);
+        if (terms.length === 0)
+            return [];
+        // Search order: user's .n8m/patterns first, then built-in docs/patterns
+        const candidateDirs = NodeDefinitionsService._testPatternsDirs ?? [
+            path.join(process.cwd(), '.n8m', 'patterns'),
+            path.join(__dirname, '..', '..', 'docs', 'patterns'), // dist
+            path.join(__dirname, '..', '..', '..', 'docs', 'patterns'), // src (dev)
+        ];
+        const matched = [];
+        const seen = new Set(); // deduplicate by filename
+        for (const dir of candidateDirs) {
+            if (!fs.existsSync(dir))
+                continue;
+            try {
+                const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+                for (const file of files) {
+                    if (seen.has(file))
+                        continue; // user pattern overrides built-in of same name
+                    const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+                    const keywordsMatch = content.match(/<!--\s*keywords:\s*([^\-]+)-->/i);
+                    if (!keywordsMatch)
+                        continue;
+                    seen.add(file);
+                    const fileKeywords = keywordsMatch[1].toLowerCase();
+                    if (terms.some(t => fileKeywords.includes(t))) {
+                        matched.push(content);
+                    }
+                }
+            }
+            catch {
+                // silently skip unreadable dirs
+            }
+        }
+        return matched;
+    }
     /**
      * Format definitions for LLM System Prompt
      */

package/dist/utils/fixtureManager.d.ts

@@ -3,6 +3,10 @@ export interface WorkflowFixture {
     capturedAt: string;
     workflowId: string;
     workflowName: string;
+    /** Human-readable label for this test case */
+    description?: string;
+    /** Whether this case should pass or fail. Defaults to 'pass'. */
+    expectedOutcome?: 'pass' | 'fail';
     workflow: any;
     execution: {
         id?: string;
@@ -20,9 +24,15 @@ export declare class FixtureManager {
     private fixturesDir;
     constructor();
     private fixturePath;
+    private fixtureDir;
     exists(workflowId: string): boolean;
+    /** Load all fixtures for a workflow. Supports both directory (new) and single-file (legacy) formats. */
+    loadAll(workflowId: string): WorkflowFixture[];
     load(workflowId: string): WorkflowFixture | null;
     loadFromPath(filePath: string): WorkflowFixture | null;
     getCapturedDate(workflowId: string): Date | null;
+    /** Save a named fixture into the per-workflow directory (new multi-fixture format). */
+    saveNamed(fixture: WorkflowFixture, name: string): Promise<void>;
+    /** Legacy single-file save (used by offerSaveFixture after live runs). */
     save(fixture: WorkflowFixture): Promise<void>;
 }

package/dist/utils/fixtureManager.js

@@ -1,5 +1,5 @@
 import fs from 'fs/promises';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync } from 'fs';
 import path from 'path';
 export class FixtureManager {
     fixturesDir;
@@ -9,8 +9,32 @@ export class FixtureManager {
     fixturePath(workflowId) {
         return path.join(this.fixturesDir, `${workflowId}.json`);
     }
+    fixtureDir(workflowId) {
+        return path.join(this.fixturesDir, workflowId);
+    }
     exists(workflowId) {
-        return existsSync(this.fixturePath(workflowId));
+        return existsSync(this.fixturePath(workflowId)) || existsSync(this.fixtureDir(workflowId));
+    }
+    /** Load all fixtures for a workflow. Supports both directory (new) and single-file (legacy) formats. */
+    loadAll(workflowId) {
+        const dir = this.fixtureDir(workflowId);
+        if (existsSync(dir)) {
+            return readdirSync(dir)
+                .filter(f => f.endsWith('.json'))
+                .sort()
+                .flatMap(f => {
+                try {
+                    const raw = readFileSync(path.join(dir, f), 'utf-8');
+                    return [JSON.parse(raw)];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        // Legacy single-file fallback
+        const single = this.load(workflowId);
+        return single ? [single] : [];
     }
     load(workflowId) {
         try {
@@ -31,9 +55,24 @@ export class FixtureManager {
         }
     }
     getCapturedDate(workflowId) {
-        const fixture = this.load(workflowId);
-        return fixture ? new Date(fixture.capturedAt) : null;
+        const fixtures = this.loadAll(workflowId);
+        if (fixtures.length === 0)
+            return null;
+        const dates = fixtures
+            .map(f => new Date(f.capturedAt))
+            .filter(d => !isNaN(d.getTime()));
+        if (dates.length === 0)
+            return null;
+        return dates.reduce((latest, d) => (d > latest ? d : latest));
+    }
+    /** Save a named fixture into the per-workflow directory (new multi-fixture format). */
+    async saveNamed(fixture, name) {
+        const dir = this.fixtureDir(fixture.workflowId);
+        await fs.mkdir(dir, { recursive: true });
+        const safeName = name.replace(/[^a-z0-9_-]/gi, '-').replace(/-+/g, '-').toLowerCase();
+        await fs.writeFile(path.join(dir, `${safeName}.json`), JSON.stringify(fixture, null, 2), 'utf-8');
     }
+    /** Legacy single-file save (used by offerSaveFixture after live runs). */
     async save(fixture) {
         await fs.mkdir(this.fixturesDir, { recursive: true });
         await fs.writeFile(this.fixturePath(fixture.workflowId), JSON.stringify(fixture, null, 2), 'utf-8');

package/dist/utils/multilinePrompt.js

@@ -1,52 +1,38 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
-import { Box, Text, render, useApp } from 'ink';
-import TextInput from 'ink-text-input';
-import { MultilineInput } from 'ink-multiline-input';
-const SmartPromptElement = ({ onDone, title }) => {
-    const [mode, setMode] = useState('single');
-    const [value, setValue] = useState('');
-    const [multiValue, setMultiValue] = useState('');
-    const { exit } = useApp();
-    const handleSingleSubmit = (text) => {
-        if (text.trim() === '```') {
-            setMode('multi');
-        }
-        else if (text.trim().length > 0) {
-            onDone(text.trim());
-            exit();
-        }
-        // If empty, do nothing (stays open)
-    };
-    const handleMultiSubmit = (text) => {
-        // End with ``` to submit
-        if (text.trim().endsWith('```')) {
-            const finalValue = text.trim();
-            const cleaned = finalValue.slice(0, -3).trim();
-            if (cleaned.length > 0) {
-                onDone(cleaned);
-                exit();
-                return;
-            }
-        }
-        setMultiValue(text + '\n');
-    };
-    if (mode === 'single') {
-        return (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "? " }), _jsxs(Text, { bold: true, children: [title || 'Describe the workflow (use ``` for multiline): ', " "] }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSingleSubmit })] }));
-    }
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "\u2714 " }), _jsxs(Text, { bold: true, children: [title || 'Describe the workflow (use ``` for multiline): ', " "] }), _jsx(Text, { color: "cyan", children: "```" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", children: "Entering multiline mode. Type ``` on a new line to finish." }) }), _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(Text, { color: "gray", children: "\u2503 " }), _jsx(Box, { flexGrow: 1, children: _jsx(MultilineInput, { value: multiValue, onChange: setMultiValue, onSubmit: handleMultiSubmit, rows: 5, maxRows: 15, keyBindings: {
-                                submit: (key) => key.return && !key.shift,
-                                newline: (key) => key.return && key.shift
-                            } }) })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", dimColor: true, children: "Arrows: Navigate | Enter: Submit (if ends with ```) | Shift+Enter: Newline" }) })] }));
-};
+import * as readline from 'node:readline';
 export async function promptMultiline(message) {
+    const label = message || 'Describe the workflow (use ``` for multiline): ';
     return new Promise((resolve) => {
-        let result = '';
-        const instance = render(_jsx(SmartPromptElement, { onDone: (val) => {
-                result = val;
-            }, title: message }));
-        instance.waitUntilExit().then(() => {
-            resolve(result);
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+        let multilineMode = false;
+        const lines = [];
+        process.stdout.write(`\x1b[32m?\x1b[0m \x1b[1m${label}\x1b[0m`);
+        const done = (value) => {
+            rl.close();
+            resolve(value);
+        };
+        rl.on('line', (line) => {
+            if (!multilineMode) {
+                if (line.trim() === '```') {
+                    multilineMode = true;
+                    process.stdout.write(`\x1b[36m  Multiline mode — type \`\`\` on its own line to finish.\x1b[0m\n`);
+                }
+                else if (line.trim().length > 0) {
+                    done(line.trim());
+                }
+                // empty line — stay open
+            }
+            else {
+                if (line.trim() === '```') {
+                    done(lines.join('\n'));
+                }
+                else {
+                    lines.push(line);
+                }
+            }
         });
     });
 }