@lhi/n8m 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,47 @@
+import { Command, Flags } from '@oclif/core';
+import { theme } from '../utils/theme.js';
+import { ConfigManager } from '../utils/config.js';
+export default class Config extends Command {
+    static description = 'Manage n8m configuration';
+    static flags = {
+        'n8n-url': Flags.string({ description: 'Set n8n Instance URL' }),
+        'n8n-key': Flags.string({ description: 'Set n8n API Key' }),
+        'ai-key': Flags.string({ description: 'Set AI API Key (used for all AI features)' }),
+        'ai-provider': Flags.string({ description: 'Set AI provider (openai, anthropic, gemini)' }),
+        'ai-model': Flags.string({ description: 'Set AI model name (e.g. gpt-4o, claude-sonnet-4-6)' }),
+        'ai-base-url': Flags.string({ description: 'Set custom AI base URL (for OpenAI-compatible endpoints)' }),
+    };
+    async run() {
+        this.log(theme.brand());
+        const { flags } = await this.parse(Config);
+        const config = await ConfigManager.load();
+        if (Object.keys(flags).length === 0) {
+            this.log(theme.header('CURRENT CONFIGURATION'));
+            this.log(theme.label('— n8n —'));
+            this.log(`${theme.label('n8n URL')}      ${config.n8nUrl ? theme.value(config.n8nUrl) : theme.muted('Not set')}`);
+            this.log(`${theme.label('n8n Key')}      ${config.n8nKey ? theme.value('********') : theme.muted('Not set')}`);
+            this.log(theme.label('— AI —'));
+            this.log(`${theme.label('AI Provider')}  ${config.aiProvider ? theme.value(config.aiProvider) : theme.muted('Not set (defaults to openai)')}`);
+            this.log(`${theme.label('AI Key')}       ${config.aiKey ? theme.value('********') : theme.muted('Not set')}`);
+            this.log(`${theme.label('AI Model')}     ${config.aiModel ? theme.value(config.aiModel) : theme.muted('Not set (uses provider default)')}`);
+            this.log(`${theme.label('AI Base URL')}  ${config.aiBaseUrl ? theme.value(config.aiBaseUrl) : theme.muted('Not set')}`);
+            this.log(theme.divider(40));
+            return;
+        }
+        // Update config
+        if (flags['n8n-url'])
+            config.n8nUrl = flags['n8n-url'];
+        if (flags['n8n-key'])
+            config.n8nKey = flags['n8n-key'];
+        if (flags['ai-key'])
+            config.aiKey = flags['ai-key'];
+        if (flags['ai-provider'])
+            config.aiProvider = flags['ai-provider'];
+        if (flags['ai-model'])
+            config.aiModel = flags['ai-model'];
+        if (flags['ai-base-url'])
+            config.aiBaseUrl = flags['ai-base-url'];
+        await ConfigManager.save(config);
+        this.log(theme.done('Configuration updated successfully'));
+    }
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Create extends Command {
+    static args: {
+        description: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        deploy: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        multiline: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/create.js

@@ -0,0 +1,182 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { theme } from '../utils/theme.js';
+import { runAgenticWorkflowStream } from '../agentic/graph.js';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import inquirer from 'inquirer';
+import { randomUUID } from 'node:crypto';
+import { graph, resumeAgenticWorkflow } from '../agentic/graph.js';
+import { promptMultiline } from '../utils/multilinePrompt.js';
+export default class Create extends Command {
+    static args = {
+        description: Args.string({
+            description: 'Natural language description of the workflow',
+            required: false,
+        }),
+    };
+    static description = 'Generate n8n workflows from natural language using Gemini AI Agent';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Send a telegram alert when I receive an email"',
+        'echo "Slack to Discord sync" | <%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --output ./my-workflow.json',
+    ];
+    static flags = {
+        deploy: Flags.boolean({
+            char: 'd',
+            description: 'Deploy the generated workflow to n8n instance (Not yet fully integrated with agent)',
+            default: false,
+            hidden: true,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Path to save the generated workflow JSON',
+        }),
+        multiline: Flags.boolean({
+            char: 'm',
+            description: 'Open editor for multiline workflow description',
+            default: false,
+        }),
+    };
+    async run() {
+        this.log(theme.brand());
+        const { args, flags } = await this.parse(Create);
+        // 1. INPUT
+        let description = args.description;
+        // Handle piped input
+        if (!description && !process.stdin.isTTY) {
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            description = Buffer.concat(chunks).toString('utf-8').trim();
+        }
+        // Handle multiline flag
+        if (!description && flags.multiline) {
+            const response = await inquirer.prompt([{
+                    type: 'editor',
+                    name: 'description',
+                    message: 'Describe the workflow you want to build (opens editor):',
+                    validate: (d) => d.trim().length > 0
+                }]);
+            description = response.description;
+        }
+        // Prompt if still empty
+        if (!description) {
+            description = await promptMultiline();
+        }
+        // Strip backticks if passed as a single block in argument or piped input
+        if (description && description.startsWith('```') && description.endsWith('```')) {
+            description = description.slice(3, -3).trim();
+        }
+        if (!description) {
+            this.error('Description is required.');
+        }
+        // 2. AGENTIC EXECUTION
+        const threadId = randomUUID();
+        this.log(theme.info(`\nInitializing Agentic Workflow for: "${description}" (Session: ${threadId})`));
+        let lastWorkflowJson = null;
+        let lastSpec = null;
+        try {
+            const stream = await runAgenticWorkflowStream(description, threadId);
+            for await (const event of stream) {
+                // event keys correspond to node names that just finished
+                const nodeName = Object.keys(event)[0];
+                const stateUpdate = event[nodeName];
+                if (nodeName === 'architect') {
+                    this.log(theme.agent(`🏗️  Architect: Blueprint designed.`));
+                    if (stateUpdate.spec?.suggestedName) {
+                        this.log(`   Goal: ${theme.value(stateUpdate.spec.suggestedName)}`);
+                        lastSpec = stateUpdate.spec;
+                    }
+                }
+                else if (nodeName === 'engineer') {
+                    this.log(theme.agent(`⚙️  Engineer: Workflow code generated/updated.`));
+                    if (stateUpdate.workflowJson) {
+                        lastWorkflowJson = stateUpdate.workflowJson;
+                    }
+                }
+                else if (nodeName === 'qa') {
+                    const status = stateUpdate.validationStatus;
+                    if (status === 'passed') {
+                        this.log(theme.success(`🧪 QA: Validation Passed!`));
+                    }
+                    else {
+                        this.log(theme.fail(`🧪 QA: Validation Failed.`));
+                        if (stateUpdate.validationErrors && stateUpdate.validationErrors.length > 0) {
+                            stateUpdate.validationErrors.forEach((e) => this.log(theme.error(`   - ${e}`)));
+                        }
+                        this.log(theme.warn(`   Looping back to Engineer for repairs...`));
+                    }
+                }
+            }
+            // Check for interrupt/pause
+            const snapshot = await graph.getState({ configurable: { thread_id: threadId } });
+            if (snapshot.next.length > 0) {
+                this.log(theme.warn(`\n⏸️  Workflow Paused at step: ${snapshot.next.join(', ')}`));
+                const { resume } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'resume',
+                        message: 'Review completed. Resume workflow execution?',
+                        default: true
+                    }]);
+                if (resume) {
+                    this.log(theme.agent("Resuming..."));
+                    // Resume recursively/iteratively? 
+                    // For now, simple resume call. ideally we'd stream again.
+                    // But wait, resumeAgenticWorkflow returns the FINAL result, not a stream.
+                    // We should probably loop if we want to stream again, but let's just create a simple resume handling here.
+                    // Or we can just call resumeAgenticWorkflow and print the final result.
+                    const result = await resumeAgenticWorkflow(threadId);
+                    if (result.validationStatus === 'passed') {
+                        this.log(theme.success(`🧪 QA (Resumed): Validation Passed!`));
+                        if (result.workflowJson)
+                            lastWorkflowJson = result.workflowJson;
+                    }
+                    else {
+                        this.log(theme.fail(`🧪 QA (Resumed): Final Status: ${result.validationStatus}`));
+                    }
+                }
+                else {
+                    this.log(theme.info(`Session persisted. Resume later with: n8m resume ${threadId}`));
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            this.error(`Agent ran into an unrecoverable error: ${error.message}`);
+        }
+        if (!lastWorkflowJson) {
+            this.error('Agent finished but no workflow JSON was produced.');
+        }
+        // 3. SAVE
+        // Normalize to array
+        const workflows = lastWorkflowJson.workflows || [lastWorkflowJson];
+        const savedResources = [];
+        for (const workflow of workflows) {
+            const workflowName = workflow.name || (lastSpec && lastSpec.suggestedName) || 'generated-workflow';
+            const sanitizedName = workflowName.replace(/[^a-z0-9]+/gi, '-').replace(/^-+|-+$/g, '').toLowerCase();
+            let targetFile = flags.output;
+            // If multiple workflows and output provided, append name to avoid overwrite, unless it's a directory
+            if (workflows.length > 1 && targetFile && !targetFile.endsWith('.json')) {
+                targetFile = path.join(targetFile, `${sanitizedName}.json`);
+            }
+            else if (workflows.length > 1 && targetFile) {
+                // If specific file given but we have multiple, suffix it
+                targetFile = targetFile.replace('.json', `-${sanitizedName}.json`);
+            }
+            else if (!targetFile) {
+                const targetDir = path.join(process.cwd(), 'workflows');
+                if (!existsSync(targetDir)) {
+                    await fs.mkdir(targetDir, { recursive: true });
+                }
+                targetFile = path.join(targetDir, `${sanitizedName}.json`);
+            }
+            await fs.writeFile(targetFile, JSON.stringify(workflow, null, 2));
+            savedResources.push({ path: targetFile, name: workflowName, original: workflow });
+            this.log(theme.success(`\nWorkflow saved to: ${targetFile}`));
+        }
+        this.log(theme.done('Agentic Workflow Complete.'));
+        process.exit(0);
+    }
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Deploy extends Command {
+    static args: {
+        workflow: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        instance: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        activate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/deploy.js

@@ -0,0 +1,68 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { theme } from '../utils/theme.js';
+export default class Deploy extends Command {
+    static args = {
+        workflow: Args.string({
+            description: 'Path to the workflow file or workflow ID',
+            required: true,
+        }),
+    };
+    static description = 'Push workflows to n8n instance via API';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./workflows/slack-notifier.json',
+    ];
+    static flags = {
+        instance: Flags.string({
+            char: 'i',
+            default: 'production',
+            description: 'n8n instance name (from config)',
+        }),
+        activate: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Activate workflow after deployment',
+        }),
+    };
+    async run() {
+        this.log(theme.brand());
+        const { args, flags } = await this.parse(Deploy);
+        this.log(theme.header('WORKFLOW DEPLOYMENT'));
+        this.log(theme.subHeader('Context Analysis'));
+        this.log(`${theme.label('Workflow')} ${theme.value(args.workflow)}`);
+        this.log(`${theme.label('Instance')} ${theme.value(flags.instance)}`);
+        this.log(`${theme.label('Auto-Activate')} ${theme.value(flags.activate)}`);
+        this.log(theme.divider(40));
+        try {
+            this.log(theme.agent('Scanning environment for local n8n instance...'));
+            let workflowData;
+            if (args.workflow.endsWith('.json')) {
+                const fs = await import('node:fs/promises');
+                const content = await fs.readFile(args.workflow, 'utf-8');
+                workflowData = JSON.parse(content);
+            }
+            else {
+                throw new Error("Local JSON file path required for currently active bridge.");
+            }
+            this.log(theme.info('Authenticating...'));
+            const { ConfigManager } = await import('../utils/config.js');
+            const config = await ConfigManager.load();
+            const n8nUrl = config.n8nUrl || process.env.N8N_API_URL;
+            const n8nKey = config.n8nKey || process.env.N8N_API_KEY;
+            if (!n8nUrl || !n8nKey) {
+                throw new Error('Missing n8n credentials. Run \'n8m config\' to set them.');
+            }
+            const { N8nClient } = await import('../utils/n8nClient.js');
+            const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+            this.log(theme.agent(`Transmitting bytecode to ${theme.secondary(n8nUrl)}`));
+            const result = await client.createWorkflow(workflowData.name || 'n8m-deployment', workflowData);
+            if (flags.activate && result.id) {
+                this.log(theme.warn('Activation request queued.'));
+            }
+            this.log(theme.done(`Deployment Successful. [ID: ${theme.primary(result.id)}]`));
+            this.log(`${theme.label('Public Link')} ${theme.secondary(client.getWorkflowLink(result.id))}`);
+        }
+        catch (error) {
+            this.error(`Operation aborted: ${error.message}`);
+        }
+    }
+}

package/dist/commands/modify.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Modify extends Command {
+    static args: {
+        workflow: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        instruction: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        multiline: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/modify.js

@@ -0,0 +1,276 @@
+import inquirer from 'inquirer';
+import { Args, Command, Flags } from '@oclif/core';
+import { theme } from '../utils/theme.js';
+import { N8nClient } from '../utils/n8nClient.js';
+import { ConfigManager } from '../utils/config.js';
+import { graph, resumeAgenticWorkflow } from '../agentic/graph.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { randomUUID } from 'node:crypto';
+import { promptMultiline } from '../utils/multilinePrompt.js';
+export default class Modify extends Command {
+    static args = {
+        workflow: Args.string({
+            description: 'Path or Name of the workflow to modify',
+            required: false,
+        }),
+        instruction: Args.string({
+            description: 'Modification instructions',
+            required: false,
+        }),
+    };
+    static description = 'Modify existing n8n workflows using Gemini AI Agent';
+    static flags = {
+        multiline: Flags.boolean({
+            char: 'm',
+            description: 'Open editor for multiline modification instructions',
+            default: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Path to save the modified workflow JSON (defaults to overwriting if local file)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Modify);
+        this.log(theme.brand());
+        this.log(theme.header('WORKFLOW MODIFICATION'));
+        // 1. Load Credentials & Client
+        const config = await ConfigManager.load();
+        const n8nUrl = config.n8nUrl || process.env.N8N_API_URL;
+        const n8nKey = config.n8nKey || process.env.N8N_API_KEY;
+        if (!n8nUrl || !n8nKey) {
+            this.error('Credentials missing. Configure environment via \'n8m config\'.');
+        }
+        const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+        // 1a. Fetch Valid Node Types
+        let validNodeTypes = [];
+        try {
+            validNodeTypes = await client.getNodeTypes();
+            if (validNodeTypes.length > 0) {
+                this.log(theme.muted(`✔ Loaded ${validNodeTypes.length} valid node types for validation.`));
+            }
+        }
+        catch (e) {
+            this.log(theme.warn(`⚠ Failed to fetch node types: ${e.message}`));
+        }
+        // 2. Resolve Workflow
+        let workflowData;
+        let workflowName = 'Untitled';
+        let originalPath = undefined;
+        let remoteId = undefined;
+        if (args.workflow && existsSync(args.workflow)) {
+            // Direct file path
+            originalPath = path.resolve(args.workflow);
+            const content = await fs.readFile(originalPath, 'utf-8');
+            workflowData = JSON.parse(content);
+            workflowName = workflowData.name || path.basename(args.workflow, '.json');
+        }
+        else {
+            // Selection Logic (similar to test.ts)
+            this.log(theme.info('Searching for local and remote workflows...'));
+            const localChoices = [];
+            const workflowsDir = path.join(process.cwd(), 'workflows');
+            const searchDirs = [workflowsDir, process.cwd()];
+            for (const dir of searchDirs) {
+                if (existsSync(dir)) {
+                    const files = await fs.readdir(dir);
+                    for (const file of files) {
+                        if (file.endsWith('.json')) {
+                            localChoices.push({
+                                name: `${theme.value('[LOCAL]')} ${file}`,
+                                value: { type: 'local', path: path.join(dir, file) }
+                            });
+                        }
+                    }
+                }
+            }
+            const remoteWorkflows = await client.getWorkflows();
+            const remoteChoices = remoteWorkflows
+                .map(w => ({
+                name: `${theme.info('[n8n]')} ${w.name} (${w.id}) ${w.active ? '[Active]' : ''}`,
+                value: { type: 'remote', id: w.id, data: w }
+            }));
+            const choices = [
+                ...(localChoices.length > 0 ? [new inquirer.Separator('--- Local Files ---'), ...localChoices] : []),
+                ...(remoteChoices.length > 0 ? [new inquirer.Separator('--- n8n Instance ---'), ...remoteChoices] : []),
+            ];
+            if (choices.length === 0)
+                this.error('No workflows found locally or on n8n instance.');
+            const { selection } = await inquirer.prompt([{
+                    type: 'select',
+                    name: 'selection',
+                    message: 'Select a workflow to modify:',
+                    choices,
+                    pageSize: 15
+                }]);
+            if (selection.type === 'local') {
+                originalPath = selection.path;
+                const content = await fs.readFile(originalPath, 'utf-8');
+                workflowData = JSON.parse(content);
+                workflowName = workflowData.name || path.basename(originalPath, '.json');
+            }
+            else {
+                remoteId = selection.id;
+                workflowData = await client.getWorkflow(remoteId);
+                workflowName = workflowData.name || 'Remote Workflow';
+            }
+        }
+        // 3. Get Instruction
+        let instruction = args.instruction;
+        if (!instruction && flags.multiline) {
+            const response = await inquirer.prompt([{
+                    type: 'editor',
+                    name: 'instruction',
+                    message: 'Describe the modifications you want to apply (opens editor):',
+                    validate: (d) => d.trim().length > 0
+                }]);
+            instruction = response.instruction;
+        }
+        if (!instruction) {
+            instruction = await promptMultiline('Describe the modifications you want to apply:');
+        }
+        if (!instruction) {
+            this.error('Modification instructions are required.');
+        }
+        // 4. AGENTIC EXECUTION
+        const threadId = randomUUID();
+        this.log(theme.info(`\nInitializing Agentic Modification for: "${workflowName}"`));
+        let lastWorkflowJson = workflowData;
+        const goal = `Modify the provided workflow based on these instructions: ${instruction}`;
+        const initialState = {
+            userGoal: goal,
+            messages: [],
+            validationErrors: [],
+            workflowJson: workflowData,
+            availableNodeTypes: validNodeTypes
+        };
+        try {
+            const stream = await graph.stream({
+                ...initialState,
+                revisionCount: 0,
+            }, {
+                configurable: { thread_id: threadId }
+            });
+            for await (const event of stream) {
+                const nodeName = Object.keys(event)[0];
+                const stateUpdate = event[nodeName];
+                if (nodeName === 'architect') {
+                    this.log(theme.agent(`🏗️  Architect: Analysis complete.`));
+                    if (stateUpdate.spec) {
+                        this.log(`   Plan: ${theme.value(stateUpdate.spec.suggestedName || 'Modifying structure')}`);
+                    }
+                }
+                else if (nodeName === 'engineer') {
+                    this.log(theme.agent(`⚙️  Engineer: Applying changes to workflow...`));
+                    if (stateUpdate.workflowJson) {
+                        lastWorkflowJson = stateUpdate.workflowJson;
+                    }
+                }
+                else if (nodeName === 'qa') {
+                    const status = stateUpdate.validationStatus;
+                    if (status === 'passed') {
+                        this.log(theme.success(`🧪 QA: Modification Validated.`));
+                    }
+                    else {
+                        this.log(theme.fail(`🧪 QA: Validation Issues Found.`));
+                        if (stateUpdate.validationErrors && stateUpdate.validationErrors.length > 0) {
+                            stateUpdate.validationErrors.forEach((e) => this.log(theme.error(`   - ${e}`)));
+                        }
+                        this.log(theme.warn(`   Looping back for refinements...`));
+                    }
+                }
+            }
+            // HITL Pause
+            const snapshot = await graph.getState({ configurable: { thread_id: threadId } });
+            if (snapshot.next.length > 0) {
+                this.log(theme.warn(`\n⏸️  Modification Paused at step: ${snapshot.next.join(', ')}`));
+                const { resume } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'resume',
+                        message: 'Review pending changes. Proceed with finalization?',
+                        default: true
+                    }]);
+                if (resume) {
+                    this.log(theme.agent("Finalizing..."));
+                    const result = await resumeAgenticWorkflow(threadId);
+                    if (result.workflowJson)
+                        lastWorkflowJson = result.workflowJson;
+                }
+                else {
+                    this.log(theme.info(`Session persisted. Thread: ${threadId}`));
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            this.error(`Agent encountered an error: ${error.message}`);
+        }
+        // 5. POST-MODIFICATION ACTIONS
+        const modifiedWorkflow = lastWorkflowJson.workflows ? lastWorkflowJson.workflows[0] : lastWorkflowJson;
+        // Self-Healing: Ensure settings and staticData exist for API compatibility
+        if (!modifiedWorkflow.settings)
+            modifiedWorkflow.settings = { executionOrder: 'v1' };
+        if (!modifiedWorkflow.staticData)
+            modifiedWorkflow.staticData = null;
+        // Preserve ID if it existed in the original and is missing in the new
+        if (workflowData.id) {
+            modifiedWorkflow.id = workflowData.id;
+        }
+        // Standardize naming
+        if (!modifiedWorkflow.name.toLowerCase().includes('modified')) {
+            // maybe add a suffix? Or just keep it. 
+        }
+        const { action } = await inquirer.prompt([{
+                type: 'select',
+                name: 'action',
+                message: 'Modification complete. What would you like to do?',
+                choices: [
+                    { name: 'Save locally', value: 'save' },
+                    { name: 'Deploy to n8n instance', value: 'deploy' },
+                    { name: 'Run ephemeral test (n8m test)', value: 'test' },
+                    { name: 'Discard changes', value: 'discard' }
+                ]
+            }]);
+        if (action === 'save') {
+            const defaultPath = flags.output || originalPath || path.join(process.cwd(), 'workflows', `${workflowName}-modified.json`);
+            const { targetPath } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'targetPath',
+                    message: 'Save modified workflow to:',
+                    default: defaultPath
+                }]);
+            await fs.mkdir(path.dirname(targetPath), { recursive: true });
+            await fs.writeFile(targetPath, JSON.stringify(modifiedWorkflow, null, 2));
+            this.log(theme.success(`✔ Saved to ${targetPath}`));
+        }
+        else if (action === 'deploy') {
+            if (remoteId) {
+                this.log(theme.info(`Updating remote workflow ${remoteId}...`));
+                await client.updateWorkflow(remoteId, modifiedWorkflow);
+                this.log(theme.success(`✔ Remote workflow updated.`));
+            }
+            else {
+                this.log(theme.info(`Creating new workflow on instance...`));
+                const payload = { ...modifiedWorkflow };
+                // Remove ID to ensure a fresh creation
+                delete payload.id;
+                const result = await client.createWorkflow(payload.name, payload);
+                this.log(theme.success(`✔ Created workflow [ID: ${result.id}]`));
+                this.log(`${theme.label('Link')} ${theme.secondary(client.getWorkflowLink(result.id))}`);
+            }
+        }
+        else if (action === 'test') {
+            // Automatically run the test command
+            const tempPath = path.join(process.cwd(), '.n8m-temp-modified.json');
+            await fs.writeFile(tempPath, JSON.stringify(modifiedWorkflow, null, 2));
+            this.log(theme.info(`Workflow staged. Running ephemeral test...`));
+            // Execute Test command
+            // We import Test to avoid circular dependency issues if we just used runCommand with string?
+            // Actually runCommand is cleaner.
+            await this.config.runCommand('test', [tempPath]);
+        }
+        this.log(theme.done('Modification Process Complete.'));
+    }
+}

package/dist/commands/prune.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Prune extends Command {
+    static description: string;
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}