@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/commands/serve.js

@@ -1,93 +0,0 @@
-/**
- * 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
- * fw serve
- *
- * # Specify workflow directory
- * fw serve ./workflows
- *
- * # Custom port
- * fw serve --port 8080
- *
- * # Production mode
- * fw serve --production --precompile
- *
- * # Disable hot reload
- * fw serve --no-watch
- * ```
- */
-export async function serveCommand(dir, options) {
-    // Check fastify is installed before proceeding
-    try {
-        await import('fastify');
-    }
-    catch {
-        logger.error('The serve command requires fastify. Install it with:');
-        logger.newline();
-        logger.log('  npm install fastify');
-        logger.newline();
-        process.exit(1);
-    }
-    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'));
-    if (process.platform !== 'win32')
-        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/status.js

@@ -1,123 +0,0 @@
-/**
- * Status command — reports implementation progress for stub workflows
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { parseWorkflow } from '../../api/index.js';
-import { validator } from '../../validator.js';
-import { logger } from '../utils/logger.js';
-import { getErrorMessage } from '../../utils/error-utils.js';
-function formatPortList(ports) {
-    return Object.entries(ports)
-        .filter(([name]) => name !== 'execute' && name !== 'onSuccess' && name !== 'onFailure')
-        .map(([name, port]) => `${name}(${port.dataType.toLowerCase()})`);
-}
-export async function statusCommand(input, options = {}) {
-    const { workflowName, json = false } = options;
-    try {
-        const filePath = path.resolve(input);
-        if (!fs.existsSync(filePath)) {
-            if (json) {
-                console.log(JSON.stringify({ error: `File not found: ${input}` }));
-            }
-            else {
-                logger.error(`File not found: ${input}`);
-            }
-            process.exitCode = 1;
-            return;
-        }
-        const parseResult = await parseWorkflow(filePath, { workflowName });
-        if (parseResult.errors.length > 0) {
-            if (json) {
-                console.log(JSON.stringify({ error: `Parse errors: ${parseResult.errors.join(', ')}` }));
-            }
-            else {
-                logger.error('Parse errors:');
-                parseResult.errors.forEach((e) => logger.error(`  ${e}`));
-            }
-            process.exitCode = 1;
-            return;
-        }
-        const ast = parseResult.ast;
-        // Collect node statuses
-        const instanceTypeMap = new Map();
-        for (const nt of ast.nodeTypes) {
-            instanceTypeMap.set(nt.name, nt);
-            if (nt.functionName !== nt.name) {
-                instanceTypeMap.set(nt.functionName, nt);
-            }
-        }
-        const nodes = [];
-        const seen = new Set();
-        for (const instance of ast.instances) {
-            const nt = instanceTypeMap.get(instance.nodeType);
-            if (!nt || seen.has(nt.functionName))
-                continue;
-            seen.add(nt.functionName);
-            nodes.push({
-                name: nt.functionName,
-                status: nt.variant === 'STUB' ? 'STUB' : 'OK',
-                inputs: formatPortList(nt.inputs),
-                outputs: formatPortList(nt.outputs),
-            });
-        }
-        const implemented = nodes.filter((n) => n.status === 'OK').length;
-        const total = nodes.length;
-        // Run draft validation for structural checks
-        const validation = validator.validate(ast, { mode: 'draft' });
-        const structuralErrors = validation.errors
-            .filter((e) => e.code !== 'STUB_NODE')
-            .map((e) => e.message);
-        const result = {
-            name: ast.name,
-            implemented,
-            total,
-            nodes,
-            structurallyValid: structuralErrors.length === 0,
-            structuralErrors,
-        };
-        if (json) {
-            // eslint-disable-next-line no-console
-            console.log(JSON.stringify(result, null, 2));
-        }
-        else {
-            logger.section(`${ast.name}: ${implemented}/${total} nodes implemented`);
-            logger.newline();
-            const maxNameLen = Math.max(...nodes.map((n) => n.name.length), 0);
-            for (const node of nodes) {
-                const tag = node.status === 'STUB' ? '[STUB]' : '[OK]  ';
-                const paddedName = node.name.padEnd(maxNameLen);
-                const inputStr = node.inputs.length > 0 ? `inputs: ${node.inputs.join(', ')}` : '';
-                const outputStr = node.outputs.length > 0 ? `outputs: ${node.outputs.join(', ')}` : '';
-                const arrow = inputStr && outputStr ? ' → ' : '';
-                const portsStr = `${inputStr}${arrow}${outputStr}`;
-                if (node.status === 'STUB') {
-                    logger.warn(`  ${paddedName}  ${tag}  ${portsStr}`);
-                }
-                else {
-                    logger.success(`  ${paddedName}  ${tag}  ${portsStr}`);
-                }
-            }
-            if (structuralErrors.length > 0) {
-                logger.newline();
-                logger.error(`Structural errors (${structuralErrors.length}):`);
-                structuralErrors.forEach((e) => logger.error(`  - ${e}`));
-            }
-            else {
-                logger.newline();
-                logger.success('Graph structure is valid.');
-            }
-        }
-    }
-    catch (error) {
-        if (json) {
-            // eslint-disable-next-line no-console
-            console.log(JSON.stringify({ error: getErrorMessage(error) }));
-        }
-        else {
-            logger.error(`Status failed: ${getErrorMessage(error)}`);
-        }
-        process.exitCode = 1;
-    }
-}
-//# sourceMappingURL=status.js.map

package/dist/cli/commands/strip.js

@@ -1,61 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import { hasInPlaceMarkers, stripGeneratedSections } from '../../api/generate-in-place.js';
-import { logger } from '../utils/logger.js';
-import { safeWriteFile } from '../utils/safe-write.js';
-export async function stripCommand(input, options = {}) {
-    const { output, dryRun = false, verbose = false } = options;
-    // 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
-    }
-    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) {
-        throw new Error(`No files found matching pattern: ${input}`);
-    }
-    const t = logger.timer();
-    let stripped = 0;
-    let skipped = 0;
-    for (const filePath of files) {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        if (!hasInPlaceMarkers(content)) {
-            skipped++;
-            if (verbose) {
-                logger.info(`Skipped (no markers): ${path.relative(process.cwd(), filePath)}`);
-            }
-            continue;
-        }
-        const result = stripGeneratedSections(content);
-        if (dryRun) {
-            logger.info(`Would strip: ${path.relative(process.cwd(), filePath)}`);
-            stripped++;
-            continue;
-        }
-        const outPath = output
-            ? path.join(path.resolve(output), path.basename(filePath))
-            : filePath;
-        safeWriteFile(outPath, result);
-        stripped++;
-        if (verbose) {
-            logger.success(`Stripped: ${path.relative(process.cwd(), outPath)}`);
-        }
-    }
-    const verb = dryRun ? 'would be stripped' : 'stripped';
-    logger.success(`${stripped} file${stripped !== 1 ? 's' : ''} ${verb}, ${skipped} skipped in ${t.elapsed()}`);
-}
-//# sourceMappingURL=strip.js.map

package/dist/cli/commands/templates.js

@@ -1,58 +0,0 @@
-/* eslint-disable no-console */
-/**
- * Templates command - list available templates
- */
-import { nodeTemplates, getAllWorkflowTemplates } from "../templates/index.js";
-import { loadPackTemplates } from "../templates/pack-loader.js";
-import { logger } from "../utils/logger.js";
-export async function templatesCommand(options = {}) {
-    const { json = false } = options;
-    // Load pack-contributed templates so they appear alongside core templates
-    await loadPackTemplates(process.cwd());
-    const allWorkflowTemplates = getAllWorkflowTemplates();
-    if (json) {
-        console.log(JSON.stringify({
-            workflows: allWorkflowTemplates.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 allWorkflowTemplates) {
-        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("  $ fw create workflow <template> <file> [--async] [--line N]");
-    logger.log("  $ fw create node <name> <file> [-t <template>] [--line N]");
-    logger.newline();
-}
-//# sourceMappingURL=templates.js.map

package/dist/cli/commands/validate.js

@@ -1,267 +0,0 @@
-/* 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}` }));
-                process.exitCode = 1;
-                return;
-            }
-            throw new Error(`No files found matching pattern: ${input}`);
-        }
-        const totalTimer = logger.timer();
-        if (!json) {
-            logger.section('Validating Workflows');
-            if (verbose) {
-                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 && verbose) {
-                logger.progress(i + 1, files.length, fileName);
-            }
-            try {
-                // Parse the workflow
-                const parseResult = await parseWorkflow(file, { workflowName, projectDir: path.dirname(path.resolve(file)) });
-                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.warn(`    How to fix: ${friendly.fix}`);
-                                if (err.docUrl) {
-                                    logger.warn(`    See: ${err.docUrl}`);
-                                }
-                            }
-                            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);
-                                if (err.docUrl) {
-                                    logger.warn(`    See: ${err.docUrl}`);
-                                }
-                            }
-                        });
-                    }
-                    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.warn(`    How to fix: ${friendly.fix}`);
-                                if (warn.docUrl) {
-                                    logger.warn(`    See: ${warn.docUrl}`);
-                                }
-                            }
-                            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);
-                                if (warn.docUrl) {
-                                    logger.warn(`    See: ${warn.docUrl}`);
-                                }
-                            }
-                        });
-                    }
-                    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
-            const elapsed = totalTimer.elapsed();
-            logger.newline();
-            if (totalErrors > 0) {
-                const parts = [`${successCount} valid`, `${totalErrors} error${totalErrors !== 1 ? 's' : ''}`];
-                if (totalWarnings > 0)
-                    parts.push(`${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''}`);
-                logger.log(`  ${parts.join(', ')} in ${elapsed}`);
-            }
-            else if (totalWarnings > 0) {
-                logger.log(`  ${successCount} valid, ${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''} in ${elapsed}`);
-            }
-            else {
-                logger.success(`${successCount} file${successCount !== 1 ? 's' : ''} valid in ${elapsed}`);
-            }
-        }
-        if (totalErrors > 0) {
-            if (json) {
-                // JSON output already emitted above — just signal failure via exit code
-                process.exitCode = 1;
-                return;
-            }
-            throw new Error(`Validation failed with ${totalErrors} error${totalErrors !== 1 ? 's' : ''}`);
-        }
-    }
-    catch (error) {
-        if (json) {
-            console.log(JSON.stringify({ error: getErrorMessage(error) }));
-            process.exitCode = 1;
-            return;
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=validate.js.map

package/dist/cli/commands/watch.js

@@ -1,71 +0,0 @@
-/**
- * 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);
-    if (process.platform !== 'win32')
-        process.on('SIGTERM', cleanup);
-    // Keep process alive
-    await new Promise(() => {
-        // Never resolves - keeps process running
-    });
-}
-//# sourceMappingURL=watch.js.map

package/dist/cli/config/credentials.d.ts

@@ -1,15 +0,0 @@
-export interface StoredCredentials {
-    token: string;
-    email: string;
-    plan: 'free' | 'pro' | 'business';
-    platformUrl: string;
-    expiresAt: number;
-    userId?: string;
-}
-export declare function loadCredentials(): StoredCredentials | null;
-export declare function saveCredentials(creds: StoredCredentials): void;
-export declare function clearCredentials(): void;
-export declare function isTokenExpired(creds: StoredCredentials): boolean;
-export declare function getPlatformUrl(): string;
-export declare function isLoggedIn(): boolean;
-//# sourceMappingURL=credentials.d.ts.map