@synergenius/flow-weaver 0.29.0 → 0.30.0

package/dist/api/parse.js

@@ -32,6 +32,7 @@ export async function parseWorkflow(filePath, options) {
         // Parse the file to extract nodes and workflows
         const parsed = parser.parse(filePath);
         warnings.push(...parsed.warnings);
+        errors.push(...parsed.errors);
         // Get available workflow names
         availableWorkflows = parsed.workflows.map((w) => w.functionName);
         // Determine which workflow to use
@@ -82,7 +83,7 @@ export async function parseWorkflow(filePath, options) {
         }
         return {
             ast: workflow,
-            errors: [],
+            errors,
             warnings,
             availableWorkflows,
             allWorkflows: parsed.workflows,

package/dist/chevrotain-parser/node-parser.js

@@ -65,14 +65,13 @@ class NodeParser extends CstParser {
         this.CONSUME(LabelPrefix);
         this.CONSUME(StringLiteral, { LABEL: 'labelValue' });
     });
-    // expr: port="value", port2="value2"
+    // expr: port="value", port2="value2"  (comma optional between assignments)
     exprAttr = this.RULE('exprAttr', () => {
         this.CONSUME(ExprPrefix);
-        this.AT_LEAST_ONE_SEP({
-            SEP: Comma,
-            DEF: () => {
-                this.SUBRULE(this.exprAssignment);
-            },
+        this.SUBRULE(this.exprAssignment);
+        this.MANY(() => {
+            this.OPTION(() => this.CONSUME(Comma));
+            this.SUBRULE2(this.exprAssignment);
         });
     });
     // port="value"
@@ -524,6 +523,10 @@ const visitorInstance = new NodeVisitor();
 export function parseNodeLine(input, warnings) {
     const lexResult = JSDocLexer.tokenize(input);
     if (lexResult.errors.length > 0) {
+        const truncatedInput = input.length > 60 ? input.substring(0, 60) + '...' : input;
+        warnings.push(`Failed to tokenize node line: "${truncatedInput}"\n` +
+            `  Error: ${lexResult.errors[0].message}\n` +
+            `  Expected format: @node instanceId NodeType`);
         return null;
     }
     // Check if starts with @node

package/dist/cli/commands/compile.js

@@ -137,48 +137,50 @@ export async function compileCommand(input, options = {}) {
                 errorCount++;
                 continue;
             }
-            // Validate the AST (especially for --strict mode)
-            if (strict) {
-                const validation = validator.validate(parseResult.ast, { strictMode: true });
-                if (validation.errors.length > 0) {
-                    logger.error(`  ${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}`);
-                            }
+            // Validate the AST
+            const validation = validator.validate(parseResult.ast, { strictMode: strict });
+            // In strict mode, validation errors block compilation
+            if (strict && validation.errors.length > 0) {
+                logger.error(`  ${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.node) {
-                                msg += ` (node: ${err.node})`;
-                            }
-                            logger.error(msg);
-                            if (err.docUrl) {
-                                logger.warn(`    See: ${err.docUrl}`);
-                            }
+                    }
+                    else {
+                        let msg = `    ${err.message}`;
+                        if (err.node) {
+                            msg += ` (node: ${err.node})`;
                         }
-                    });
-                    errorCount++;
-                    continue;
-                }
-                if (validation.warnings.length > 0 && verbose) {
-                    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}`);
+                        logger.error(msg);
+                        if (err.docUrl) {
+                            logger.warn(`    See: ${err.docUrl}`);
                         }
-                        else {
-                            logger.warn(`  ${warn.message}`);
+                    }
+                });
+                errorCount++;
+                continue;
+            }
+            // Always show validation warnings (not just in verbose mode)
+            if (validation.warnings.length > 0) {
+                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}`);
+                        if (verbose) {
+                            logger.warn(`    How to fix: ${friendly.fix}`);
                         }
-                    });
-                }
+                    }
+                    else {
+                        logger.warn(`  ${warn.message}`);
+                    }
+                });
             }
             // Read original source
             const sourceCode = fs.readFileSync(file, 'utf8');

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

@@ -13,6 +13,10 @@ export interface DevOptions extends DevModeOptions {
     clean?: boolean;
     /** Compilation target (default: typescript in-place) */
     target?: string;
+    /** Mock config for built-in nodes as JSON string */
+    mocks?: string;
+    /** Path to JSON file with mock config */
+    mocksFile?: string;
 }
 /**
  * Dev command: watch + compile + run in a single loop.

package/dist/cli/commands/dev.js

@@ -52,11 +52,38 @@ function parseParams(options) {
     }
     return {};
 }
+/**
+ * Parse mock config from --mocks or --mocks-file.
+ */
+function parseMocks(options) {
+    if (options.mocks) {
+        try {
+            return JSON.parse(options.mocks);
+        }
+        catch {
+            throw new Error(`Invalid JSON in --mocks: ${options.mocks}`);
+        }
+    }
+    if (options.mocksFile) {
+        const mocksFilePath = path.resolve(options.mocksFile);
+        if (!fs.existsSync(mocksFilePath)) {
+            throw new Error(`Mocks file not found: ${mocksFilePath}`);
+        }
+        try {
+            const content = fs.readFileSync(mocksFilePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch {
+            throw new Error(`Failed to parse mocks file: ${options.mocksFile}`);
+        }
+    }
+    return undefined;
+}
 /**
  * Run a single compile + execute cycle.
  * Returns true if both compile and run succeeded.
  */
-async function compileAndRun(filePath, params, options) {
+async function compileAndRun(filePath, params, mocks, options) {
     // Step 1: Compile
     const compileOpts = {
         format: options.format,
@@ -96,6 +123,7 @@ async function compileAndRun(filePath, params, options) {
             workflowName: options.workflow,
             production: options.production ?? false,
             includeTrace: !options.production,
+            mocks,
         });
         if (options.json) {
             process.stdout.write(JSON.stringify({
@@ -143,16 +171,20 @@ export async function devCommand(input, options = {}) {
         throw new Error(`Unknown dev target "${options.target}". ${available.length ? `Available: ${available.join(', ')}` : 'No dev mode providers registered. Install a pack that provides one.'}`);
     }
     const params = parseParams(options);
+    const mocks = parseMocks(options);
     if (!options.json) {
         logger.section('Dev Mode');
         logger.info(`File: ${path.basename(filePath)}`);
         if (Object.keys(params).length > 0) {
             logger.info(`Params: ${JSON.stringify(params)}`);
         }
+        if (mocks) {
+            logger.info(`Mocks: ${JSON.stringify(mocks)}`);
+        }
         logger.newline();
     }
     // Initial compile + run
-    await compileAndRun(filePath, params, options);
+    await compileAndRun(filePath, params, mocks, options);
     // If --once, exit after first cycle
     if (options.once) {
         return;
@@ -173,7 +205,7 @@ export async function devCommand(input, options = {}) {
         if (!options.json) {
             cycleSeparator(file);
         }
-        await compileAndRun(filePath, params, options);
+        await compileAndRun(filePath, params, mocks, options);
     });
     // Handle process termination
     const cleanup = () => {

package/dist/cli/flow-weaver.mjs

@@ -5987,7 +5987,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.29.0";
+    VERSION = "0.30.0";
   }
 });
 
@@ -24365,6 +24365,12 @@ var init_port_parser = __esm({
 function parseNodeLine(input, warnings) {
   const lexResult = JSDocLexer.tokenize(input);
   if (lexResult.errors.length > 0) {
+    const truncatedInput = input.length > 60 ? input.substring(0, 60) + "..." : input;
+    warnings.push(
+      `Failed to tokenize node line: "${truncatedInput}"
+  Error: ${lexResult.errors[0].message}
+  Expected format: @node instanceId NodeType`
+    );
     return null;
   }
   if (lexResult.tokens.length === 0) {
@@ -24452,14 +24458,13 @@ var init_node_parser = __esm({
         this.CONSUME(LabelPrefix);
         this.CONSUME(StringLiteral, { LABEL: "labelValue" });
       });
-      // expr: port="value", port2="value2"
+      // expr: port="value", port2="value2"  (comma optional between assignments)
       exprAttr = this.RULE("exprAttr", () => {
         this.CONSUME(ExprPrefix);
-        this.AT_LEAST_ONE_SEP({
-          SEP: Comma,
-          DEF: () => {
-            this.SUBRULE(this.exprAssignment);
-          }
+        this.SUBRULE(this.exprAssignment);
+        this.MANY(() => {
+          this.OPTION(() => this.CONSUME(Comma));
+          this.SUBRULE2(this.exprAssignment);
         });
       });
       // port="value"
@@ -30075,6 +30080,7 @@ async function parseWorkflow(filePath, options) {
     }
     const parsed = parser.parse(filePath);
     warnings.push(...parsed.warnings);
+    errors2.push(...parsed.errors);
     availableWorkflows = parsed.workflows.map((w) => w.functionName);
     let workflowName = options?.workflowName;
     if (!workflowName) {
@@ -30124,7 +30130,7 @@ async function parseWorkflow(filePath, options) {
     }
     return {
       ast: workflow,
-      errors: [],
+      errors: errors2,
       warnings,
       availableWorkflows,
       allWorkflows: parsed.workflows
@@ -47596,45 +47602,45 @@ async function compileCommand(input, options = {}) {
         errorCount++;
         continue;
       }
-      if (strict) {
-        const validation = validator.validate(parseResult.ast, { strictMode: true });
-        if (validation.errors.length > 0) {
-          logger.error(`  ${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.node) {
-                msg += ` (node: ${err.node})`;
-              }
-              logger.error(msg);
-              if (err.docUrl) {
-                logger.warn(`    See: ${err.docUrl}`);
-              }
+      const validation = validator.validate(parseResult.ast, { strictMode: strict });
+      if (strict && validation.errors.length > 0) {
+        logger.error(`  ${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}`);
             }
-          });
-          errorCount++;
-          continue;
-        }
-        if (validation.warnings.length > 0 && verbose) {
-          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}`);
+          } else {
+            let msg = `    ${err.message}`;
+            if (err.node) {
+              msg += ` (node: ${err.node})`;
+            }
+            logger.error(msg);
+            if (err.docUrl) {
+              logger.warn(`    See: ${err.docUrl}`);
+            }
+          }
+        });
+        errorCount++;
+        continue;
+      }
+      if (validation.warnings.length > 0) {
+        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}`);
+            if (verbose) {
               logger.warn(`    How to fix: ${friendly.fix}`);
-            } else {
-              logger.warn(`  ${warn.message}`);
             }
-          });
-        }
+          } else {
+            logger.warn(`  ${warn.message}`);
+          }
+        });
       }
       const sourceCode = fs11.readFileSync(file, "utf8");
       const result = generateInPlace(sourceCode, parseResult.ast, { production, moduleFormat, sourceFile: file, skipParamReturns: clean });
@@ -60756,7 +60762,29 @@ function parseParams(options) {
   }
   return {};
 }
-async function compileAndRun(filePath, params, options) {
+function parseMocks(options) {
+  if (options.mocks) {
+    try {
+      return JSON.parse(options.mocks);
+    } catch {
+      throw new Error(`Invalid JSON in --mocks: ${options.mocks}`);
+    }
+  }
+  if (options.mocksFile) {
+    const mocksFilePath = path21.resolve(options.mocksFile);
+    if (!fs21.existsSync(mocksFilePath)) {
+      throw new Error(`Mocks file not found: ${mocksFilePath}`);
+    }
+    try {
+      const content = fs21.readFileSync(mocksFilePath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      throw new Error(`Failed to parse mocks file: ${options.mocksFile}`);
+    }
+  }
+  return void 0;
+}
+async function compileAndRun(filePath, params, mocks, options) {
   const compileOpts = {
     format: options.format,
     clean: options.clean
@@ -60790,7 +60818,8 @@ async function compileAndRun(filePath, params, options) {
     const result = await executeWorkflowFromFile(filePath, params, {
       workflowName: options.workflow,
       production: options.production ?? false,
-      includeTrace: !options.production
+      includeTrace: !options.production,
+      mocks
     });
     if (options.json) {
       process.stdout.write(
@@ -60838,15 +60867,19 @@ async function devCommand(input, options = {}) {
     );
   }
   const params = parseParams(options);
+  const mocks = parseMocks(options);
   if (!options.json) {
     logger.section("Dev Mode");
     logger.info(`File: ${path21.basename(filePath)}`);
     if (Object.keys(params).length > 0) {
       logger.info(`Params: ${JSON.stringify(params)}`);
     }
+    if (mocks) {
+      logger.info(`Mocks: ${JSON.stringify(mocks)}`);
+    }
     logger.newline();
   }
-  await compileAndRun(filePath, params, options);
+  await compileAndRun(filePath, params, mocks, options);
   if (options.once) {
     return;
   }
@@ -60864,7 +60897,7 @@ async function devCommand(input, options = {}) {
     if (!options.json) {
       cycleSeparator(file);
     }
-    await compileAndRun(filePath, params, options);
+    await compileAndRun(filePath, params, mocks, options);
   });
   const cleanup = () => {
     if (!options.json) {
@@ -88927,7 +88960,7 @@ function parseIntStrict(value) {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.29.0" : "0.0.0-dev";
+var version2 = true ? "0.30.0" : "0.0.0-dev";
 var program2 = new Command();
 program2.name("fw").description("Flow Weaver Annotations - Compile and validate workflow files").option("-v, --version", "Output the current version").option("--no-color", "Disable colors").option("--color", "Force colors").on("option:version", () => {
   logger.banner(version2);
@@ -89003,7 +89036,7 @@ program2.command("watch <input>").description("Watch workflow files and recompil
   if (options.workflow) options.workflowName = options.workflow;
   await watchCommand2(input, options);
 }));
-program2.command("dev <input>").description("Watch, compile, and run workflow on changes").option("--params <json>", "Input parameters as JSON string").option("--params-file <path>", "Path to JSON file with input parameters").option("-w, --workflow <name>", "Specific workflow name to run").option("-p, --production", "Run in production mode (no trace events)", false).option("-f, --format <format>", "Module format: esm, cjs, or auto", "auto").option("--clean", "Omit redundant @param/@returns annotations", false).option("--once", "Run once then exit", false).option("--json", "Output result as JSON", false).option("--target <target>", "Compilation target (default: typescript)").action(wrapAction(async (input, options) => {
+program2.command("dev <input>").description("Watch, compile, and run workflow on changes").option("--params <json>", "Input parameters as JSON string").option("--params-file <path>", "Path to JSON file with input parameters").option("-w, --workflow <name>", "Specific workflow name to run").option("-p, --production", "Run in production mode (no trace events)", false).option("-f, --format <format>", "Module format: esm, cjs, or auto", "auto").option("--clean", "Omit redundant @param/@returns annotations", false).option("--once", "Run once then exit", false).option("--json", "Output result as JSON", false).option("--target <target>", "Compilation target (default: typescript)").option("--mocks <json>", "Mock config for built-in nodes (events, invocations, agents, fast) as JSON").option("--mocks-file <path>", "Path to JSON file with mock config for built-in nodes").action(wrapAction(async (input, options) => {
   const { devCommand: devCommand2 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
   await devCommand2(input, options);
 }));

package/dist/cli/index.js

@@ -223,6 +223,8 @@ program
     .option('--once', 'Run once then exit', false)
     .option('--json', 'Output result as JSON', false)
     .option('--target <target>', 'Compilation target (default: typescript)')
+    .option('--mocks <json>', 'Mock config for built-in nodes (events, invocations, agents, fast) as JSON')
+    .option('--mocks-file <path>', 'Path to JSON file with mock config for built-in nodes')
     .action(wrapAction(async (input, options) => {
     const { devCommand } = await import('./commands/dev.js');
     await devCommand(input, options);

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.29.0";
+export declare const VERSION = "0.30.0";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.29.0';
+export const VERSION = '0.30.0';
 //# sourceMappingURL=generated-version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Flow Weaver: deterministic TypeScript workflow compiler. Define workflows with JSDoc annotations, compile to standalone functions with zero runtime dependencies.",
   "private": false,
   "type": "module",