@synergenius/flow-weaver 0.2.0

package/dist/cli/commands/serve.js

@@ -0,0 +1,81 @@
+/**
+ * Serve command - start HTTP server exposing workflows as endpoints
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import { WebhookServer } from '../../server/webhook-server.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Start a webhook server exposing workflows as HTTP endpoints.
+ *
+ * @param dir - Directory containing workflow files (defaults to current directory)
+ * @param options - Server options
+ *
+ * @example
+ * ```bash
+ * # Start server with current directory
+ * flow-weaver serve
+ *
+ * # Specify workflow directory
+ * flow-weaver serve ./workflows
+ *
+ * # Custom port
+ * flow-weaver serve --port 8080
+ *
+ * # Production mode
+ * flow-weaver serve --production --precompile
+ *
+ * # Disable hot reload
+ * flow-weaver serve --no-watch
+ * ```
+ */
+export async function serveCommand(dir, options) {
+    const workflowDir = path.resolve(dir || '.');
+    // Validate directory exists
+    if (!fs.existsSync(workflowDir)) {
+        throw new Error(`Directory not found: ${workflowDir}`);
+    }
+    if (!fs.statSync(workflowDir).isDirectory()) {
+        throw new Error(`Not a directory: ${workflowDir}`);
+    }
+    const port = options.port ?? 3000;
+    const host = options.host ?? '0.0.0.0';
+    logger.section('Flow Weaver Webhook Server');
+    logger.info(`Workflow directory: ${workflowDir}`);
+    logger.info(`Server: http://${host}:${port}`);
+    logger.info(`File watching: ${options.watch !== false ? 'enabled' : 'disabled'}`);
+    logger.info(`Production mode: ${options.production ? 'yes' : 'no'}`);
+    if (options.swagger) {
+        logger.info(`Swagger UI: http://${host}:${port}/docs`);
+    }
+    logger.newline();
+    const server = new WebhookServer({
+        port,
+        host,
+        workflowDir,
+        watchEnabled: options.watch !== false,
+        production: options.production ?? false,
+        precompile: options.precompile ?? false,
+        corsOrigin: options.cors ?? '*',
+        swaggerEnabled: options.swagger ?? false,
+    });
+    // Graceful shutdown handlers
+    const shutdown = async (signal) => {
+        logger.newline();
+        logger.info(`Received ${signal}, shutting down...`);
+        await server.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    try {
+        await server.start();
+    }
+    catch (error) {
+        if (error.code === 'EADDRINUSE') {
+            throw new Error(`Port ${port} is already in use. Try a different port with --port <number>`);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=serve.js.map

package/dist/cli/commands/templates.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Templates command - list available templates
+ */
+export interface TemplatesOptions {
+    json?: boolean;
+}
+export declare function templatesCommand(options?: TemplatesOptions): Promise<void>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/cli/commands/templates.js

@@ -0,0 +1,54 @@
+/* eslint-disable no-console */
+/**
+ * Templates command - list available templates
+ */
+import { workflowTemplates, nodeTemplates } from "../templates/index.js";
+import { logger } from "../utils/logger.js";
+export async function templatesCommand(options = {}) {
+    const { json = false } = options;
+    if (json) {
+        console.log(JSON.stringify({
+            workflows: workflowTemplates.map((t) => ({
+                id: t.id,
+                name: t.name,
+                description: t.description,
+                category: t.category,
+            })),
+            nodes: nodeTemplates.map((t) => ({
+                id: t.id,
+                name: t.name,
+                description: t.description,
+            })),
+        }, null, 2));
+        return;
+    }
+    logger.section("Workflow Templates");
+    logger.newline();
+    // Group by category
+    const categories = new Map();
+    for (const template of workflowTemplates) {
+        const cat = template.category;
+        if (!categories.has(cat)) {
+            categories.set(cat, []);
+        }
+        categories.get(cat).push(template);
+    }
+    for (const [category, templates] of categories) {
+        logger.info(`  ${category}:`);
+        for (const t of templates) {
+            logger.log(`    ${t.id.padEnd(15)} ${t.description}`);
+        }
+        logger.newline();
+    }
+    logger.section("Node Templates");
+    logger.newline();
+    for (const t of nodeTemplates) {
+        logger.log(`  ${t.id.padEnd(15)} ${t.description}`);
+    }
+    logger.newline();
+    logger.section("Usage");
+    logger.log("  $ flow-weaver create workflow <template> <file> [--async] [--line N]");
+    logger.log("  $ flow-weaver create node <template> <name> <file> [--line N]");
+    logger.newline();
+}
+//# sourceMappingURL=templates.js.map

package/dist/cli/commands/ui.d.ts

@@ -0,0 +1,16 @@
+export declare function uiFocusNode(nodeId: string, options: {
+    server?: string;
+}): Promise<void>;
+export declare function uiAddNode(nodeTypeName: string, options: {
+    server?: string;
+}): Promise<void>;
+export declare function uiOpenWorkflow(filePath: string, options: {
+    server?: string;
+}): Promise<void>;
+export declare function uiGetState(options: {
+    server?: string;
+}): Promise<void>;
+export declare function uiBatch(json: string, options: {
+    server?: string;
+}): Promise<void>;
+//# sourceMappingURL=ui.d.ts.map

package/dist/cli/commands/ui.js

@@ -0,0 +1,130 @@
+import { io as socketIO } from 'socket.io-client';
+import { logger } from '../utils/logger.js';
+import { DEFAULT_SERVER_URL } from '../../defaults.js';
+const DEFAULT_SERVER = DEFAULT_SERVER_URL;
+const ACK_TIMEOUT = 10_000;
+const VERBOSE_OUTPUT = !!(process.env.DEBUG || process.argv.includes('--verbose'));
+async function sendCommand(serverUrl, action, params) {
+    const socket = socketIO(`${serverUrl}/integrations`, {
+        query: { clientType: 'cli' },
+        transports: ['websocket', 'polling'],
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            socket.on('connect', () => resolve());
+            socket.on('connect_error', (err) => reject(err));
+            setTimeout(() => reject(new Error('Connection timeout')), ACK_TIMEOUT);
+        });
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const result = await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                resolve({ requestId, success: false, error: 'Timeout' });
+            }, ACK_TIMEOUT);
+            socket.on('fw:ack', (data) => {
+                if (data.requestId === requestId) {
+                    clearTimeout(timeout);
+                    resolve(data);
+                }
+            });
+            socket.emit('integration:command', { requestId, action, params });
+        });
+        if (result.success) {
+            if (VERBOSE_OUTPUT) {
+                logger.success(JSON.stringify(result, null, 2));
+            }
+            else {
+                logger.success(`Command "${action}" executed successfully`);
+            }
+        }
+        else {
+            logger.error(VERBOSE_OUTPUT
+                ? JSON.stringify(result, null, 2)
+                : `Command "${action}" failed: ${result.error || 'unknown error'}`);
+            process.exitCode = 1;
+        }
+    }
+    catch (err) {
+        logger.error(String(err instanceof Error ? err.message : err));
+        process.exitCode = 1;
+    }
+    finally {
+        socket.disconnect();
+    }
+}
+async function sendBatch(serverUrl, commands) {
+    const socket = socketIO(`${serverUrl}/integrations`, {
+        query: { clientType: 'cli' },
+        transports: ['websocket', 'polling'],
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            socket.on('connect', () => resolve());
+            socket.on('connect_error', (err) => reject(err));
+            setTimeout(() => reject(new Error('Connection timeout')), ACK_TIMEOUT);
+        });
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const result = await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                resolve({ requestId, success: false, error: 'Timeout' });
+            }, ACK_TIMEOUT);
+            socket.on('fw:ack', (data) => {
+                if (data.requestId === requestId) {
+                    clearTimeout(timeout);
+                    resolve(data);
+                }
+            });
+            socket.emit('integration:batch', { requestId, commands });
+        });
+        if (result.success) {
+            if (VERBOSE_OUTPUT) {
+                logger.success(JSON.stringify(result, null, 2));
+            }
+            else {
+                logger.success('Batch executed successfully');
+            }
+        }
+        else {
+            logger.error(VERBOSE_OUTPUT
+                ? JSON.stringify(result, null, 2)
+                : `Batch failed: ${result.error || 'unknown error'}`);
+            process.exitCode = 1;
+        }
+    }
+    catch (err) {
+        logger.error(String(err instanceof Error ? err.message : err));
+        process.exitCode = 1;
+    }
+    finally {
+        socket.disconnect();
+    }
+}
+export async function uiFocusNode(nodeId, options) {
+    const server = options.server || DEFAULT_SERVER;
+    await sendCommand(server, 'focus-node', { nodeId });
+}
+export async function uiAddNode(nodeTypeName, options) {
+    const server = options.server || DEFAULT_SERVER;
+    await sendCommand(server, 'add-node', { nodeTypeName });
+}
+export async function uiOpenWorkflow(filePath, options) {
+    const server = options.server || DEFAULT_SERVER;
+    await sendCommand(server, 'open-workflow', { filePath });
+}
+export async function uiGetState(options) {
+    const server = options.server || DEFAULT_SERVER;
+    await sendCommand(server, 'get-state', {});
+}
+export async function uiBatch(json, options) {
+    let commands;
+    try {
+        commands = JSON.parse(json);
+    }
+    catch {
+        logger.error('Invalid JSON. Provide an array of {action, params} objects.');
+        process.exitCode = 1;
+        return;
+    }
+    const server = options.server || DEFAULT_SERVER;
+    await sendBatch(server, commands);
+}
+//# sourceMappingURL=ui.js.map

package/dist/cli/commands/validate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Validate command - validates workflow files without compiling
+ */
+export interface ValidateOptions {
+    verbose?: boolean;
+    quiet?: boolean;
+    workflowName?: string;
+    json?: boolean;
+    strict?: boolean;
+}
+export declare function validateCommand(input: string, options?: ValidateOptions): Promise<void>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/cli/commands/validate.js

@@ -0,0 +1,247 @@
+/* eslint-disable no-console */
+/**
+ * Validate command - validates workflow files without compiling
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import { parseWorkflow } from '../../api/index.js';
+import { validator } from '../../validator.js';
+import { getFriendlyError } from '../../friendly-errors.js';
+import { logger } from '../utils/logger.js';
+import { getErrorMessage } from '../../utils/error-utils.js';
+import { getAgentValidationRules } from '../../validation/agent-rules.js';
+export async function validateCommand(input, options = {}) {
+    const { verbose = false, quiet = false, workflowName, json = false, strict = false } = options;
+    try {
+        // If input is a directory, expand to all .ts files recursively
+        let pattern = input;
+        try {
+            if (fs.existsSync(input) && fs.statSync(input).isDirectory()) {
+                pattern = path.join(input, '**/*.ts');
+            }
+        }
+        catch {
+            // Not a valid path, use as glob pattern
+        }
+        // Find files matching the pattern, filter to actual files only
+        const allFiles = await glob(pattern, { absolute: true });
+        const files = allFiles.filter((f) => {
+            try {
+                return fs.statSync(f).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+        if (files.length === 0) {
+            if (json) {
+                console.log(JSON.stringify({ error: `No files found matching pattern: ${input}` }));
+            }
+            else {
+                logger.error(`No files found matching pattern: ${input}`);
+            }
+            process.exit(1);
+        }
+        if (!json) {
+            logger.section('Validating Workflows');
+            logger.info(`Found ${files.length} file(s)`);
+            logger.newline();
+        }
+        let totalErrors = 0;
+        let totalWarnings = 0;
+        let successCount = 0;
+        const jsonResults = [];
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const fileName = path.basename(file);
+            if (!json) {
+                logger.progress(i + 1, files.length, fileName);
+            }
+            try {
+                // Parse the workflow
+                const parseResult = await parseWorkflow(file, { workflowName });
+                if (parseResult.warnings.length > 0) {
+                    if (!json && !quiet) {
+                        logger.warn(`Parse warnings in ${fileName}:`);
+                        parseResult.warnings.forEach((w) => logger.warn(`  - ${w}`));
+                    }
+                    totalWarnings += parseResult.warnings.length;
+                }
+                if (parseResult.errors.length > 0) {
+                    // Skip non-workflow files silently (only error is "No workflows found")
+                    const isNonWorkflowFile = parseResult.errors.length === 1 &&
+                        typeof parseResult.errors[0] === 'string' &&
+                        parseResult.errors[0].startsWith('No workflows found');
+                    if (isNonWorkflowFile) {
+                        if (verbose && !json) {
+                            logger.debug(`  Skipped ${fileName} (no workflow)`);
+                        }
+                        continue;
+                    }
+                    if (json) {
+                        jsonResults.push({
+                            file,
+                            valid: false,
+                            errors: parseResult.errors.map((e) => typeof e === 'string' ? { message: e, severity: 'error' } : e),
+                            warnings: parseResult.warnings.map((w) => typeof w === 'string' ? { message: w, severity: 'warning' } : w),
+                        });
+                    }
+                    else {
+                        logger.error(`Parse errors in ${fileName}:`);
+                        parseResult.errors.forEach((err) => logger.error(`  ${err}`));
+                    }
+                    totalErrors += parseResult.errors.length;
+                    continue;
+                }
+                // Validate the AST (built-in rules)
+                const validation = validator.validate(parseResult.ast, { strictMode: strict });
+                // Run agent-specific validation rules
+                const agentRules = getAgentValidationRules();
+                for (const rule of agentRules) {
+                    const ruleErrors = rule.validate(parseResult.ast);
+                    for (const err of ruleErrors) {
+                        if (err.type === 'warning') {
+                            validation.warnings.push(err);
+                        }
+                        else {
+                            validation.errors.push(err);
+                            validation.valid = false;
+                        }
+                    }
+                }
+                if (json) {
+                    jsonResults.push({
+                        file,
+                        valid: validation.valid,
+                        errors: validation.errors.map((e) => ({
+                            message: e.message,
+                            severity: e.type || 'error',
+                            ...(e.node && { nodeId: e.node }),
+                            ...(e.code && { code: e.code }),
+                        })),
+                        warnings: [
+                            ...parseResult.warnings.map((w) => typeof w === 'string' ? { message: w, severity: 'warning' } : w),
+                            ...validation.warnings.map((w) => ({
+                                message: w.message,
+                                severity: w.type || 'warning',
+                                ...(w.node && { nodeId: w.node }),
+                                ...(w.code && { code: w.code }),
+                            })),
+                        ],
+                    });
+                }
+                if (validation.errors.length > 0) {
+                    if (!json) {
+                        logger.error(`Validation errors in ${fileName}:`);
+                        validation.errors.forEach((err) => {
+                            const friendly = getFriendlyError(err);
+                            if (friendly) {
+                                const loc = err.location ? `[line ${err.location.line}] ` : '';
+                                logger.error(`  ${loc}${friendly.title}: ${friendly.explanation}`);
+                                logger.info(`    How to fix: ${friendly.fix}`);
+                            }
+                            else {
+                                let msg = `  - ${err.message}`;
+                                if (err.location) {
+                                    msg = `  [line ${err.location.line}] - ${err.message}`;
+                                }
+                                if (err.node) {
+                                    msg += ` (node: ${err.node})`;
+                                }
+                                if (err.connection) {
+                                    msg += ` (connection: ${err.connection.from.node}:${err.connection.from.port} -> ${err.connection.to.node}:${err.connection.to.port})`;
+                                }
+                                logger.error(msg);
+                            }
+                        });
+                    }
+                    totalErrors += validation.errors.length;
+                }
+                if (validation.warnings.length > 0) {
+                    if (!json && !quiet) {
+                        logger.warn(`Warnings in ${fileName}:`);
+                        validation.warnings.forEach((warn) => {
+                            const friendly = getFriendlyError(warn);
+                            if (friendly) {
+                                const loc = warn.location ? `[line ${warn.location.line}] ` : '';
+                                logger.warn(`  ${loc}${friendly.title}: ${friendly.explanation}`);
+                                logger.info(`    How to fix: ${friendly.fix}`);
+                            }
+                            else {
+                                let msg = `  - ${warn.message}`;
+                                if (warn.location) {
+                                    msg = `  [line ${warn.location.line}] - ${warn.message}`;
+                                }
+                                if (warn.node) {
+                                    msg += ` (node: ${warn.node})`;
+                                }
+                                logger.warn(msg);
+                            }
+                        });
+                    }
+                    totalWarnings += validation.warnings.length;
+                }
+                if (validation.valid) {
+                    if (!json && verbose) {
+                        logger.success(`  ${fileName} is valid`);
+                    }
+                    successCount++;
+                }
+            }
+            catch (error) {
+                if (json) {
+                    jsonResults.push({
+                        file,
+                        valid: false,
+                        errors: [{ message: getErrorMessage(error), severity: 'error' }],
+                        warnings: [],
+                    });
+                }
+                else {
+                    logger.error(`Failed to validate ${fileName}: ${getErrorMessage(error)}`);
+                }
+                totalErrors++;
+            }
+        }
+        // Output
+        if (json) {
+            console.log(JSON.stringify({
+                valid: totalErrors === 0,
+                totalFiles: files.length,
+                validFiles: successCount,
+                totalErrors,
+                totalWarnings,
+                results: jsonResults,
+            }, null, 2));
+        }
+        else {
+            // Summary
+            logger.newline();
+            logger.section('Validation Summary');
+            logger.success(`${successCount} file(s) valid`);
+            if (totalWarnings > 0) {
+                logger.warn(`${totalWarnings} warning(s) found`);
+            }
+            if (totalErrors > 0) {
+                logger.error(`${totalErrors} error(s) found`);
+            }
+            else {
+                logger.success('All workflows are valid!');
+            }
+        }
+        if (totalErrors > 0) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (json) {
+            console.log(JSON.stringify({ error: getErrorMessage(error) }));
+        }
+        else {
+            logger.error(`Validation failed: ${getErrorMessage(error)}`);
+        }
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/cli/commands/watch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Watch command - watches workflow files and recompiles on changes
+ */
+import { type CompileOptions } from './compile.js';
+export interface WatchOptions extends CompileOptions {
+    onRecompile?: (filePath: string, success: boolean, errors?: string[]) => void;
+}
+export declare function watchCommand(input: string, options?: WatchOptions): Promise<void>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/cli/commands/watch.js

@@ -0,0 +1,70 @@
+/**
+ * Watch command - watches workflow files and recompiles on changes
+ */
+import * as path from 'path';
+import { glob } from 'glob';
+import { compileCommand } from './compile.js';
+import { logger } from '../utils/logger.js';
+import { getErrorMessage } from '../../utils/error-utils.js';
+function timestamp() {
+    const now = new Date();
+    const h = String(now.getHours()).padStart(2, '0');
+    const m = String(now.getMinutes()).padStart(2, '0');
+    const s = String(now.getSeconds()).padStart(2, '0');
+    return `[${h}:${m}:${s}]`;
+}
+export async function watchCommand(input, options = {}) {
+    logger.section('Watch Mode');
+    logger.info(`Watching for changes: ${input}`);
+    logger.info('Press Ctrl+C to stop');
+    logger.newline();
+    // Initial compilation
+    logger.info('Initial compilation...');
+    await compileCommand(input, options);
+    logger.newline();
+    logger.success('Watching for file changes...');
+    // Find files to watch
+    const files = await glob(input, { absolute: true });
+    // Use chokidar for reliable cross-platform file watching
+    const chokidar = await import('chokidar');
+    const watcher = chokidar.watch(files, {
+        persistent: true,
+        ignoreInitial: true,
+    });
+    watcher.on('change', async (file) => {
+        logger.newline();
+        logger.info(`${timestamp()} File changed: ${path.basename(file)}`);
+        logger.info(`${timestamp()} Recompiling...`);
+        logger.newline();
+        try {
+            await compileCommand(file, options);
+            logger.newline();
+            logger.success(`${timestamp()} Recompilation complete`);
+            options.onRecompile?.(file, true);
+        }
+        catch (error) {
+            const errorMsg = getErrorMessage(error);
+            logger.error(`${timestamp()} Recompilation failed: ${errorMsg}`);
+            options.onRecompile?.(file, false, [errorMsg]);
+        }
+    });
+    if (options.verbose) {
+        for (const file of files) {
+            logger.debug(`Watching: ${file}`);
+        }
+    }
+    // Handle process termination
+    const cleanup = () => {
+        logger.newline();
+        logger.info('Stopping watch mode...');
+        watcher.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    // Keep process alive
+    await new Promise(() => {
+        // Never resolves - keeps process running
+    });
+}
+//# sourceMappingURL=watch.js.map