@synergenius/flow-weaver 0.23.5 → 0.24.1

package/dist/cli/commands/diagram.js

@@ -6,38 +6,31 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileToSVG, fileToHTML, fileToASCII } from '../../diagram/index.js';
 import { logger } from '../utils/logger.js';
-import { getErrorMessage } from '../../utils/error-utils.js';
+import { safeWriteFile } from '../utils/safe-write.js';
 const ASCII_FORMATS = new Set(['ascii', 'ascii-compact', 'text']);
 export async function diagramCommand(input, options = {}) {
     const { output, format = 'svg', ...diagramOptions } = options;
     const filePath = path.resolve(input);
     if (!fs.existsSync(filePath)) {
-        logger.error(`File not found: ${filePath}`);
-        process.exit(1);
+        throw new Error(`File not found: ${filePath}`);
     }
-    try {
-        let result;
-        if (ASCII_FORMATS.has(format)) {
-            result = fileToASCII(filePath, { ...diagramOptions, format });
-        }
-        else if (format === 'html') {
-            result = fileToHTML(filePath, diagramOptions);
-        }
-        else {
-            result = fileToSVG(filePath, diagramOptions);
-        }
-        if (output) {
-            const outputPath = path.resolve(output);
-            fs.writeFileSync(outputPath, result, 'utf-8');
-            logger.success(`Diagram written to ${outputPath}`);
-        }
-        else {
-            process.stdout.write(result);
-        }
+    let result;
+    if (ASCII_FORMATS.has(format)) {
+        result = fileToASCII(filePath, { ...diagramOptions, format });
     }
-    catch (error) {
-        logger.error(`Failed to generate diagram: ${getErrorMessage(error)}`);
-        process.exit(1);
+    else if (format === 'html') {
+        result = fileToHTML(filePath, diagramOptions);
+    }
+    else {
+        result = fileToSVG(filePath, diagramOptions);
+    }
+    if (output) {
+        const outputPath = path.resolve(output);
+        safeWriteFile(outputPath, result);
+        logger.success(`Diagram written to ${outputPath}`);
+    }
+    else {
+        process.stdout.write(result);
     }
 }
 //# sourceMappingURL=diagram.js.map

package/dist/cli/commands/diff.js

@@ -13,12 +13,10 @@ export async function diffCommand(file1, file2, options = {}) {
     const filePath2 = path.resolve(file2);
     // Validate files exist
     if (!fs.existsSync(filePath1)) {
-        logger.error(`File not found: ${filePath1}`);
-        process.exit(1);
+        throw new Error(`File not found: ${filePath1}`);
     }
     if (!fs.existsSync(filePath2)) {
-        logger.error(`File not found: ${filePath2}`);
-        process.exit(1);
+        throw new Error(`File not found: ${filePath2}`);
     }
     try {
         // Parse both workflows
@@ -27,14 +25,10 @@ export async function diffCommand(file1, file2, options = {}) {
             parseWorkflow(filePath2, { workflowName }),
         ]);
         if (result1.errors.length > 0) {
-            logger.error(`Parse errors in ${file1}:`);
-            result1.errors.forEach((err) => logger.error(`  ${err}`));
-            process.exit(1);
+            throw new Error(`Parse errors in ${file1}:\n${result1.errors.map((err) => `  ${err}`).join('\n')}`);
         }
         if (result2.errors.length > 0) {
-            logger.error(`Parse errors in ${file2}:`);
-            result2.errors.forEach((err) => logger.error(`  ${err}`));
-            process.exit(1);
+            throw new Error(`Parse errors in ${file2}:\n${result2.errors.map((err) => `  ${err}`).join('\n')}`);
         }
         // Compare workflows
         const diff = WorkflowDiffer.compare(result1.ast, result2.ast);
@@ -50,15 +44,14 @@ export async function diffCommand(file1, file2, options = {}) {
         else {
             // eslint-disable-next-line no-console
             console.log(formatDiff(diff, format));
-            // Exit with code 1 if there are differences (useful for CI)
+            // Throw if there are differences (useful for CI)
             if (!exitZero) {
-                process.exit(1);
+                throw new Error('Workflows have differences');
             }
         }
     }
     catch (error) {
-        logger.error(`Failed to diff workflows: ${getErrorMessage(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to diff workflows: ${getErrorMessage(error)}`);
     }
 }
 //# sourceMappingURL=diff.js.map

package/dist/cli/commands/docs.js

@@ -3,8 +3,7 @@ import { logger } from '../utils/logger.js';
 export async function docsListCommand(options) {
     const topics = listTopics();
     if (topics.length === 0) {
-        logger.error('No documentation topics found.');
-        process.exit(1);
+        throw new Error('No documentation topics found.');
     }
     if (options.json) {
         process.stdout.write(JSON.stringify({ topics }, null, 2) + '\n');
@@ -25,16 +24,14 @@ export async function docsReadCommand(topic, options) {
     if (options.json) {
         const structured = readTopicStructured(topic);
         if (!structured) {
-            logger.error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
-            process.exit(1);
+            throw new Error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
         }
         process.stdout.write(JSON.stringify(structured, null, 2) + '\n');
         return;
     }
     const doc = readTopic(topic, options.compact);
     if (!doc) {
-        logger.error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
-        process.exit(1);
+        throw new Error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
     }
     process.stdout.write(doc.content + '\n');
 }

package/dist/cli/commands/doctor.js

@@ -707,7 +707,7 @@ export async function doctorCommand(options = {}) {
         }
     }
     if (!report.ok) {
-        process.exit(1);
+        throw new Error('Doctor found issues that need to be fixed');
     }
 }
 //# sourceMappingURL=doctor.js.map

package/dist/cli/commands/export.js

@@ -66,7 +66,7 @@ export async function exportCommand(input, options) {
         input,
         output: options.output,
         workflow: options.workflow,
-        production: options.production ?? true,
+        production: options.production ?? false,
         bundle: options.bundle,
         dryRun: isDryRun,
         multi: isMulti,

package/dist/cli/commands/grammar.js

@@ -1,10 +1,10 @@
 /**
  * Grammar command - output JSDoc grammar as HTML railroad diagrams or EBNF text
  */
-import * as fs from 'fs';
 import { generateGrammarDiagrams, getAllGrammars, serializedToEBNF, } from '../../chevrotain-parser/grammar-diagrams.js';
 import { logger } from '../utils/logger.js';
 import { getErrorMessage } from '../../utils/error-utils.js';
+import { safeWriteFile } from '../utils/safe-write.js';
 export async function grammarCommand(options = {}) {
     // Default to ebnf on TTY (readable in terminal), html when writing to file
     const defaultFormat = options.output ? 'html' : (process.stdout.isTTY ? 'ebnf' : 'html');
@@ -26,7 +26,7 @@ export async function grammarCommand(options = {}) {
             content = generateGrammarDiagrams();
         }
         if (output) {
-            fs.writeFileSync(output, content, 'utf-8');
+            safeWriteFile(output, content);
             logger.success(`Grammar written to ${output}`);
         }
         else {
@@ -34,8 +34,7 @@ export async function grammarCommand(options = {}) {
         }
     }
     catch (error) {
-        logger.error(`Grammar generation failed: ${getErrorMessage(error)}`);
-        process.exit(1);
+        throw new Error(`Grammar generation failed: ${getErrorMessage(error)}`);
     }
 }
 //# sourceMappingURL=grammar.js.map

package/dist/cli/commands/implement.js

@@ -7,6 +7,7 @@ import { parseWorkflow } from '../../api/index.js';
 import { generateFunctionSignature } from '../../annotation-generator.js';
 import { logger } from '../utils/logger.js';
 import { getErrorMessage } from '../../utils/error-utils.js';
+import { safeWriteFile } from '../utils/safe-write.js';
 /**
  * Find a `declare function <name>(...): ...;` declaration in source text,
  * handling multiline signatures. Returns the full matched text and its
@@ -37,14 +38,11 @@ export async function implementCommand(input, nodeName, options = {}) {
     try {
         const filePath = path.resolve(input);
         if (!fs.existsSync(filePath)) {
-            logger.error(`File not found: ${input}`);
-            process.exit(1);
+            throw new Error(`File not found: ${input}`);
         }
         const parseResult = await parseWorkflow(filePath, { workflowName });
         if (parseResult.errors.length > 0) {
-            logger.error('Parse errors:');
-            parseResult.errors.forEach((e) => logger.error(`  ${e}`));
-            process.exit(1);
+            throw new Error(`Parse errors:\n${parseResult.errors.map((e) => `  ${e}`).join('\n')}`);
         }
         const ast = parseResult.ast;
         // Find the stub node type
@@ -59,18 +57,16 @@ export async function implementCommand(input, nodeName, options = {}) {
                 .filter((nt) => nt.variant === 'STUB')
                 .map((nt) => nt.functionName);
             if (available.length === 0) {
-                logger.error('No stub nodes found in this workflow.');
+                throw new Error('No stub nodes found in this workflow.');
             }
             else {
-                logger.error(`Stub node "${nodeName}" not found. Available stubs: ${available.join(', ')}`);
+                throw new Error(`Stub node "${nodeName}" not found. Available stubs: ${available.join(', ')}`);
             }
-            process.exit(1);
         }
         const source = fs.readFileSync(filePath, 'utf8');
         const found = findDeclareFunction(source, stubNodeType.functionName);
         if (!found) {
-            logger.error(`Could not find "declare function ${stubNodeType.functionName}" in source file.`);
-            process.exit(1);
+            throw new Error(`Could not find "declare function ${stubNodeType.functionName}" in source file.`);
         }
         // Generate the real function signature
         const implementedType = { ...stubNodeType, variant: 'FUNCTION' };
@@ -84,13 +80,12 @@ export async function implementCommand(input, nodeName, options = {}) {
         }
         else {
             const updated = source.replace(found.match, replacement);
-            fs.writeFileSync(filePath, updated, 'utf8');
+            safeWriteFile(filePath, updated);
             logger.success(`Implemented ${stubNodeType.functionName} in ${path.basename(filePath)}`);
         }
     }
     catch (error) {
-        logger.error(`Implement failed: ${getErrorMessage(error)}`);
-        process.exit(1);
+        throw new Error(`Implement failed: ${getErrorMessage(error)}`);
     }
 }
 //# sourceMappingURL=implement.js.map

package/dist/cli/commands/market.js

@@ -24,13 +24,11 @@ export async function marketInitCommand(name, options = {}) {
         if (stat.isDirectory()) {
             const contents = fs.readdirSync(targetDir);
             if (contents.length > 0) {
-                logger.error(`Directory "${name}" already exists and is not empty`);
-                process.exit(1);
+                throw new Error(`Directory "${name}" already exists and is not empty`);
             }
         }
         else {
-            logger.error(`"${name}" already exists and is not a directory`);
-            process.exit(1);
+            throw new Error(`"${name}" already exists and is not a directory`);
         }
     }
     logger.section('Creating Marketplace Package');
@@ -211,8 +209,7 @@ export async function marketPackCommand(directory, options = {}) {
     }
     if (!validation.valid) {
         logger.newline();
-        logger.error('Package validation failed. Fix errors above before publishing.');
-        process.exit(1);
+        throw new Error('Package validation failed. Fix errors above before publishing.');
     }
     // 3. Write manifest
     const outPath = writeManifest(dir, manifest);
@@ -253,8 +250,7 @@ export async function marketPublishCommand(directory, options = {}) {
         }
     }
     catch (err) {
-        logger.error(`npm publish failed: ${getErrorMessage(err)}`);
-        process.exit(1);
+        throw new Error(`npm publish failed: ${getErrorMessage(err)}`);
     }
 }
 /**

package/dist/cli/commands/migrate.js

@@ -13,6 +13,7 @@ import { generateInPlace } from '../../api/generate-in-place.js';
 import { WorkflowDiffer, formatDiff } from '../../diff/index.js';
 import { applyMigrations, getRegisteredMigrations } from '../../migration/registry.js';
 import { logger } from '../utils/logger.js';
+import { safeWriteFile } from '../utils/safe-write.js';
 import { getErrorMessage } from '../../utils/error-utils.js';
 export async function migrateCommand(globPattern, options = {}) {
     const { dryRun = false, diff = false } = options;
@@ -69,7 +70,7 @@ export async function migrateCommand(globPattern, options = {}) {
                 migratedCount++;
                 continue;
             }
-            fs.writeFileSync(filePath, genResult.code, 'utf8');
+            safeWriteFile(filePath, genResult.code);
             logger.success(`  ${file}: migrated`);
             migratedCount++;
         }

package/dist/cli/commands/modify.js

@@ -4,6 +4,7 @@ import { parseWorkflow } from '../../api/index.js';
 import { generateInPlace } from '../../api/generate-in-place.js';
 import { applyModifyOperation, validateModifyParams } from '../../api/modify-operation.js';
 import { logger } from '../utils/logger.js';
+import { safeWriteFile } from '../utils/safe-write.js';
 async function readParseModifyWrite(file, operation, params) {
     const validation = validateModifyParams(operation, params);
     if (!validation.success) {
@@ -17,7 +18,7 @@ async function readParseModifyWrite(file, operation, params) {
     }
     const { ast: modifiedAST, warnings } = applyModifyOperation(parseResult.ast, operation, params);
     const result = generateInPlace(source, modifiedAST);
-    fs.writeFileSync(filePath, result.code, 'utf-8');
+    safeWriteFile(filePath, result.code);
     for (const w of warnings) {
         logger.warn(w);
     }

package/dist/cli/commands/openapi.js

@@ -6,6 +6,7 @@ import * as fs from 'fs';
 import { WorkflowRegistry } from '../../server/workflow-registry.js';
 import { generateOpenAPIJson, generateOpenAPIYaml } from '../../deployment/openapi/generator.js';
 import { logger } from '../utils/logger.js';
+import { safeWriteFile } from '../utils/safe-write.js';
 /**
  * Generate OpenAPI specification from workflows in a directory.
  *
@@ -59,7 +60,7 @@ export async function openapiCommand(dir, options) {
     // Output
     if (options.output) {
         const outputPath = path.resolve(options.output);
-        fs.writeFileSync(outputPath, spec);
+        safeWriteFile(outputPath, spec);
         logger.success(`OpenAPI specification written to ${outputPath}`);
     }
     else {

package/dist/cli/commands/pattern.js

@@ -10,6 +10,7 @@ import * as path from 'path';
 import { glob } from 'glob';
 import { AnnotationParser } from '../../parser.js';
 import { logger } from '../utils/logger.js';
+import { safeWriteFile } from '../utils/safe-write.js';
 import { listPatterns, applyPattern, extractPattern } from '../../api/patterns.js';
 const parser = new AnnotationParser();
 /**
@@ -132,7 +133,7 @@ export async function patternApplyCommand(patternFile, targetFile, options) {
         return;
     }
     // Write modified content
-    fs.writeFileSync(targetFile, result.modifiedContent);
+    safeWriteFile(targetFile, result.modifiedContent);
     logger.success(`Applied pattern "${pattern.name}" to ${targetFile}`);
     if (result.nodeTypesAdded.length > 0) {
         logger.info(`Added node types: ${result.nodeTypesAdded.join(', ')}`);
@@ -176,7 +177,7 @@ export async function patternExtractCommand(sourceFile, options) {
         return;
     }
     // Write to output file
-    fs.writeFileSync(options.output, result.patternCode);
+    safeWriteFile(options.output, result.patternCode);
     logger.success(`Extracted pattern "${result.patternName}" to ${options.output}`);
     logger.info(`Included nodes: ${result.nodes.join(', ')}`);
     logger.info(`Input ports: ${result.inputPorts.join(', ') || 'none'}`);

package/dist/cli/commands/strip.js

@@ -3,6 +3,7 @@ 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
@@ -25,8 +26,7 @@ export async function stripCommand(input, options = {}) {
         }
     });
     if (files.length === 0) {
-        logger.error(`No files found matching pattern: ${input}`);
-        process.exit(1);
+        throw new Error(`No files found matching pattern: ${input}`);
     }
     const t = logger.timer();
     let stripped = 0;
@@ -49,10 +49,7 @@ export async function stripCommand(input, options = {}) {
         const outPath = output
             ? path.join(path.resolve(output), path.basename(filePath))
             : filePath;
-        if (output) {
-            fs.mkdirSync(path.dirname(outPath), { recursive: true });
-        }
-        fs.writeFileSync(outPath, result);
+        safeWriteFile(outPath, result);
         stripped++;
         if (verbose) {
             logger.success(`Stripped: ${path.relative(process.cwd(), outPath)}`);

package/dist/cli/commands/validate.js

@@ -247,7 +247,12 @@ export async function validateCommand(input, options = {}) {
             }
         }
         if (totalErrors > 0) {
-            process.exit(1);
+            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) {