@synergenius/flow-weaver 0.23.4 → 0.24.0

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) {