@synergenius/flow-weaver 0.15.2 → 0.17.0

package/dist/cli/commands/mcp-setup.d.ts

@@ -2,6 +2,10 @@
  * mcp-setup command — detect AI coding tools and configure the Flow Weaver MCP server.
  */
 export type ToolId = 'claude' | 'cursor' | 'vscode' | 'windsurf' | 'codex' | 'openclaw';
+/** Tools that can be spawned as interactive CLI sessions */
+export declare const CLI_TOOL_IDS: ReadonlySet<ToolId>;
+/** Binary name to spawn for each CLI tool */
+export declare const CLI_TOOL_BINARY: Partial<Record<ToolId, string>>;
 export interface McpSetupDeps {
     execCommand: (cmd: string) => Promise<{
         stdout: string;
@@ -40,6 +44,19 @@ export declare function mergeJsonConfig(deps: McpSetupDeps, filePath: string, ro
 }>;
 export declare const TOOL_REGISTRY: ToolDefinition[];
 export declare function detectTools(deps: McpSetupDeps): Promise<DetectedTool[]>;
+export interface McpSetupFromInitResult {
+    configured: string[];
+    failed: string[];
+    /** Tool IDs that can be spawned as interactive CLI sessions (e.g. claude, codex) */
+    cliTools: ToolId[];
+    /** Tool IDs that are GUI-only editors (e.g. cursor, vscode, windsurf) */
+    guiTools: ToolId[];
+}
+/**
+ * Detect and configure all AI tools without interactive prompts.
+ * Used by the init command after the user has already consented.
+ */
+export declare function runMcpSetupFromInit(deps?: McpSetupDeps): Promise<McpSetupFromInitResult>;
 export declare function mcpSetupCommand(options: McpSetupOptions, deps?: McpSetupDeps): Promise<void>;
 export {};
 //# sourceMappingURL=mcp-setup.d.ts.map

package/dist/cli/commands/mcp-setup.js

@@ -12,6 +12,13 @@ import { isNonInteractive } from './init.js';
 const MCP_COMMAND = 'npx';
 const MCP_ARGS = ['@synergenius/flow-weaver@latest', 'mcp-server', '--stdio'];
 const MCP_ENTRY = { command: MCP_COMMAND, args: [...MCP_ARGS] };
+/** Tools that can be spawned as interactive CLI sessions */
+export const CLI_TOOL_IDS = new Set(['claude', 'codex']);
+/** Binary name to spawn for each CLI tool */
+export const CLI_TOOL_BINARY = {
+    claude: 'claude',
+    codex: 'codex',
+};
 // ── Deps ─────────────────────────────────────────────────────────────────────
 export function defaultDeps() {
     return {
@@ -261,6 +268,43 @@ async function configureTool(tool, deps) {
         return { id: tool.id, displayName: tool.displayName, action: 'failed', detail: msg };
     }
 }
+/**
+ * Detect and configure all AI tools without interactive prompts.
+ * Used by the init command after the user has already consented.
+ */
+export async function runMcpSetupFromInit(deps) {
+    const d = deps ?? defaultDeps();
+    const detected = await detectTools(d);
+    const toConfig = detected.filter((t) => t.detected && !t.configured);
+    const configured = [];
+    const failed = [];
+    const toolMap = new Map(TOOL_REGISTRY.map((t) => [t.id, t]));
+    for (const t of toConfig) {
+        const tool = toolMap.get(t.id);
+        if (!tool)
+            continue;
+        const result = await configureTool(tool, d);
+        if (result.action === 'configured') {
+            configured.push(result.displayName);
+        }
+        else if (result.action === 'failed') {
+            failed.push(result.displayName);
+        }
+    }
+    // Include already-configured tools in the configured list
+    for (const t of detected) {
+        if (t.configured) {
+            configured.push(t.displayName);
+        }
+    }
+    // Classify configured/detected tools as CLI or GUI
+    const allConfiguredIds = detected
+        .filter((t) => t.detected && (t.configured || configured.includes(t.displayName)))
+        .map((t) => t.id);
+    const cliTools = allConfiguredIds.filter((id) => CLI_TOOL_IDS.has(id));
+    const guiTools = allConfiguredIds.filter((id) => !CLI_TOOL_IDS.has(id));
+    return { configured, failed, cliTools, guiTools };
+}
 // ── Command ──────────────────────────────────────────────────────────────────
 export async function mcpSetupCommand(options, deps) {
     const d = deps ?? defaultDeps();

package/dist/cli/commands/migrate.js

@@ -25,6 +25,7 @@ export async function migrateCommand(globPattern, options = {}) {
     if (registeredMigrations.length > 0) {
         logger.info(`Registered edge-case migrations: ${registeredMigrations.map((m) => m.name).join(', ')}`);
     }
+    const t = logger.timer();
     let migratedCount = 0;
     let skippedCount = 0;
     let errorCount = 0;
@@ -80,10 +81,10 @@ export async function migrateCommand(globPattern, options = {}) {
     // Summary
     logger.newline();
     if (dryRun) {
-        logger.info(`Dry run complete: ${migratedCount} file(s) would be updated, ${skippedCount} already current, ${errorCount} error(s)`);
+        logger.info(`Dry run: ${migratedCount} file(s) would be updated, ${skippedCount} already current, ${errorCount} error(s) in ${t.elapsed()}`);
     }
     else {
-        logger.info(`Migration complete: ${migratedCount} file(s) updated, ${skippedCount} already current, ${errorCount} error(s)`);
+        logger.info(`${migratedCount} file(s) migrated, ${skippedCount} already current, ${errorCount} error(s) in ${t.elapsed()}`);
     }
 }
 //# sourceMappingURL=migrate.js.map

package/dist/cli/commands/openapi.js

@@ -40,7 +40,10 @@ export async function openapiCommand(dir, options) {
     if (endpoints.length === 0) {
         throw new Error(`No workflows found in ${workflowDir}`);
     }
-    logger.info(`Found ${endpoints.length} workflow(s)`);
+    // Only print info when writing to file (not stdout) to avoid contaminating JSON/YAML output
+    if (options.output) {
+        logger.info(`Found ${endpoints.length} workflow(s)`);
+    }
     // Generate options
     const generatorOptions = {
         title: options.title || 'Flow Weaver API',

package/dist/cli/commands/run.js

@@ -13,6 +13,14 @@ import { logger } from '../utils/logger.js';
 import { getFriendlyError } from '../../friendly-errors.js';
 import { getErrorMessage } from '../../utils/error-utils.js';
 import { parseWorkflow } from '../../api/index.js';
+/** Show path relative to cwd for cleaner output */
+function displayPath(filePath) {
+    const rel = path.relative(process.cwd(), filePath);
+    if (rel && !rel.startsWith('..') && rel.length < filePath.length) {
+        return rel;
+    }
+    return filePath;
+}
 /**
  * Execute a workflow file and output the result.
  *
@@ -38,10 +46,24 @@ import { parseWorkflow } from '../../api/index.js';
  * ```
  */
 export async function runCommand(input, options) {
+    // Wrap entire body in JSON-aware error handler when --json is set (0b fix)
+    if (options.json) {
+        try {
+            await runCommandInner(input, options);
+        }
+        catch (e) {
+            console.log(JSON.stringify({ success: false, error: getErrorMessage(e) }));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    await runCommandInner(input, options);
+}
+async function runCommandInner(input, options) {
     const filePath = path.resolve(input);
     // Validate file exists
     if (!fs.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
+        throw new Error(`File not found: ${displayPath(filePath)}`);
     }
     // Parse params from --params or --params-file
     let params = {};
@@ -119,7 +141,7 @@ export async function runCommand(input, options) {
                 ? options.resume
                 : findLatestCheckpoint(filePath, options.workflow);
             if (!checkpointPath) {
-                throw new Error(`No checkpoint file found for ${filePath}. ` +
+                throw new Error(`No checkpoint file found for ${displayPath(filePath)}. ` +
                     'Checkpoints are created when running with --checkpoint.');
             }
             const { data, stale, rerunNodes, skipNodes } = loadCheckpoint(checkpointPath, filePath);
@@ -147,9 +169,9 @@ export async function runCommand(input, options) {
             }
         }
         // Determine trace inclusion:
-        // - If --production is set, no trace (unless --trace explicitly set)
-        // - If --trace is set, include trace
-        // - Default: include trace in dev mode
+        // Include trace data if --trace or --stream is explicitly set.
+        // Also include when not in production mode (needed for debug/checkpoint).
+        // Display of trace results is gated separately on options.trace/options.stream.
         const includeTrace = options.stream || options.trace || !options.production;
         if (!options.json && mocks) {
             logger.info('Running with mock data');
@@ -317,17 +339,20 @@ export async function runCommand(input, options) {
             logger.newline();
             logger.section('Result');
             logger.log(JSON.stringify(result.result, null, 2));
-            if (result.trace && result.trace.length > 0) {
+            // Show trace summary only when --trace is explicitly set (not on --stream, which already printed live)
+            if (options.trace && !options.stream && result.trace && result.trace.length > 0) {
                 logger.newline();
                 logger.section('Trace');
                 logger.log(`${result.trace.length} events captured`);
-                // Show first few trace events as summary
-                const preview = result.trace.slice(0, 5);
+                // Show first few trace events as summary (skip events without nodeId)
+                const meaningful = result.trace.filter((e) => e.data?.nodeId || e.data?.id);
+                const preview = meaningful.slice(0, 5);
                 for (const event of preview) {
-                    logger.log(`  [${event.type}] ${event.data?.nodeId || ''}`);
+                    const nodeId = (event.data?.nodeId || event.data?.id || '');
+                    logger.log(`  [${event.type}] ${nodeId}`);
                 }
-                if (result.trace.length > 5) {
-                    logger.log(`  ... and ${result.trace.length - 5} more events`);
+                if (meaningful.length > 5) {
+                    logger.log(`  ... and ${meaningful.length - 5} more events`);
                 }
             }
         }
@@ -344,7 +369,7 @@ export async function runCommand(input, options) {
                 const friendly = getFriendlyError(err);
                 if (friendly) {
                     logger.error(`  ${friendly.title}: ${friendly.explanation}`);
-                    logger.info(`    How to fix: ${friendly.fix}`);
+                    logger.warn(`    How to fix: ${friendly.fix}`);
                 }
                 else {
                     logger.error(`  - ${err.message}`);
@@ -355,7 +380,7 @@ export async function runCommand(input, options) {
             const friendly = getFriendlyError({ code: errorObj.code, message: errorMsg });
             if (friendly) {
                 logger.error(`${friendly.title}: ${friendly.explanation}`);
-                logger.info(`  How to fix: ${friendly.fix}`);
+                logger.warn(`  How to fix: ${friendly.fix}`);
             }
             else {
                 logger.error(`Workflow execution failed: ${errorMsg}`);
@@ -364,11 +389,14 @@ export async function runCommand(input, options) {
         else {
             logger.error(`Workflow execution failed: ${errorMsg}`);
         }
-        if (!options.json) {
-            throw error;
+        if (options.json) {
+            // JSON mode: output structured error (0a fix: set exit code)
+            process.stdout.write(JSON.stringify({ success: false, error: errorMsg }, null, 2) + '\n');
+            process.exitCode = 1;
         }
         else {
-            process.stdout.write(JSON.stringify({ success: false, error: errorMsg }, null, 2) + '\n');
+            // Non-json mode: don't re-throw to avoid duplicate error from wrapAction (0c fix)
+            process.exitCode = 1;
         }
     }
     finally {

package/dist/cli/commands/status.js

@@ -23,7 +23,8 @@ export async function statusCommand(input, options = {}) {
             else {
                 logger.error(`File not found: ${input}`);
             }
-            process.exit(1);
+            process.exitCode = 1;
+            return;
         }
         const parseResult = await parseWorkflow(filePath, { workflowName });
         if (parseResult.errors.length > 0) {
@@ -34,7 +35,8 @@ export async function statusCommand(input, options = {}) {
                 logger.error('Parse errors:');
                 parseResult.errors.forEach((e) => logger.error(`  ${e}`));
             }
-            process.exit(1);
+            process.exitCode = 1;
+            return;
         }
         const ast = parseResult.ast;
         // Collect node statuses
@@ -115,7 +117,7 @@ export async function statusCommand(input, options = {}) {
         else {
             logger.error(`Status failed: ${getErrorMessage(error)}`);
         }
-        process.exit(1);
+        process.exitCode = 1;
     }
 }
 //# sourceMappingURL=status.js.map

package/dist/cli/commands/strip.js

@@ -28,6 +28,7 @@ export async function stripCommand(input, options = {}) {
         logger.error(`No files found matching pattern: ${input}`);
         process.exit(1);
     }
+    const t = logger.timer();
     let stripped = 0;
     let skipped = 0;
     for (const filePath of files) {
@@ -57,6 +58,7 @@ export async function stripCommand(input, options = {}) {
             logger.success(`Stripped: ${path.relative(process.cwd(), outPath)}`);
         }
     }
-    logger.success(`${stripped} file${stripped !== 1 ? 's' : ''} stripped, ${skipped} skipped`);
+    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

@@ -48,7 +48,7 @@ export async function templatesCommand(options = {}) {
     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.log("  $ flow-weaver create node <name> <file> [-t <template>] [--line N]");
     logger.newline();
 }
 //# sourceMappingURL=templates.js.map

package/dist/cli/commands/validate.js

@@ -37,16 +37,18 @@ export async function validateCommand(input, options = {}) {
         if (files.length === 0) {
             if (json) {
                 console.log(JSON.stringify({ error: `No files found matching pattern: ${input}` }));
+                process.exitCode = 1;
+                return;
             }
-            else {
-                logger.error(`No files found matching pattern: ${input}`);
-            }
-            process.exit(1);
+            throw new Error(`No files found matching pattern: ${input}`);
         }
+        const totalTimer = logger.timer();
         if (!json) {
             logger.section('Validating Workflows');
-            logger.info(`Found ${files.length} file(s)`);
-            logger.newline();
+            if (verbose) {
+                logger.info(`Found ${files.length} file(s)`);
+                logger.newline();
+            }
         }
         let totalErrors = 0;
         let totalWarnings = 0;
@@ -55,7 +57,7 @@ export async function validateCommand(input, options = {}) {
         for (let i = 0; i < files.length; i++) {
             const file = files[i];
             const fileName = path.basename(file);
-            if (!json) {
+            if (!json && verbose) {
                 logger.progress(i + 1, files.length, fileName);
             }
             try {
@@ -139,9 +141,9 @@ export async function validateCommand(input, options = {}) {
                             if (friendly) {
                                 const loc = err.location ? `[line ${err.location.line}] ` : '';
                                 logger.error(`  ${loc}${friendly.title}: ${friendly.explanation}`);
-                                logger.info(`    How to fix: ${friendly.fix}`);
+                                logger.warn(`    How to fix: ${friendly.fix}`);
                                 if (err.docUrl) {
-                                    logger.info(`    See: ${err.docUrl}`);
+                                    logger.warn(`    See: ${err.docUrl}`);
                                 }
                             }
                             else {
@@ -157,7 +159,7 @@ export async function validateCommand(input, options = {}) {
                                 }
                                 logger.error(msg);
                                 if (err.docUrl) {
-                                    logger.info(`    See: ${err.docUrl}`);
+                                    logger.warn(`    See: ${err.docUrl}`);
                                 }
                             }
                         });
@@ -172,9 +174,9 @@ export async function validateCommand(input, options = {}) {
                             if (friendly) {
                                 const loc = warn.location ? `[line ${warn.location.line}] ` : '';
                                 logger.warn(`  ${loc}${friendly.title}: ${friendly.explanation}`);
-                                logger.info(`    How to fix: ${friendly.fix}`);
+                                logger.warn(`    How to fix: ${friendly.fix}`);
                                 if (warn.docUrl) {
-                                    logger.info(`    See: ${warn.docUrl}`);
+                                    logger.warn(`    See: ${warn.docUrl}`);
                                 }
                             }
                             else {
@@ -187,7 +189,7 @@ export async function validateCommand(input, options = {}) {
                                 }
                                 logger.warn(msg);
                                 if (warn.docUrl) {
-                                    logger.info(`    See: ${warn.docUrl}`);
+                                    logger.warn(`    See: ${warn.docUrl}`);
                                 }
                             }
                         });
@@ -229,17 +231,19 @@ export async function validateCommand(input, options = {}) {
         }
         else {
             // Summary
+            const elapsed = totalTimer.elapsed();
             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`);
+                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('All workflows are valid!');
+                logger.success(`${successCount} file${successCount !== 1 ? 's' : ''} valid in ${elapsed}`);
             }
         }
         if (totalErrors > 0) {
@@ -249,11 +253,10 @@ export async function validateCommand(input, options = {}) {
     catch (error) {
         if (json) {
             console.log(JSON.stringify({ error: getErrorMessage(error) }));
+            process.exitCode = 1;
+            return;
         }
-        else {
-            logger.error(`Validation failed: ${getErrorMessage(error)}`);
-        }
-        process.exit(1);
+        throw error;
     }
 }
 //# sourceMappingURL=validate.js.map

package/dist/cli/env-setup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Environment setup that must run before any color library imports.
+ * This module is imported first in index.ts to ensure picocolors reads the correct env vars.
+ */
+//# sourceMappingURL=env-setup.d.ts.map

package/dist/cli/env-setup.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Environment setup that must run before any color library imports.
+ * This module is imported first in index.ts to ensure picocolors reads the correct env vars.
+ */
+// FORCE_COLOR=0 should disable colors, but picocolors treats any non-empty
+// FORCE_COLOR as "enable colors". Translate to NO_COLOR which picocolors checks first.
+if (process.env.FORCE_COLOR === '0') {
+    process.env.NO_COLOR = '1';
+    delete process.env.FORCE_COLOR;
+}
+//# sourceMappingURL=env-setup.js.map