@synergenius/flow-weaver 0.2.0

package/dist/cli/commands/dev.js

@@ -0,0 +1,384 @@
+/**
+ * Dev command - watch, compile, and run workflow on changes
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { glob } from 'glob';
+import { spawn } from 'child_process';
+import { compileCommand, compileInngestTarget } from './compile.js';
+import { executeWorkflowFromFile } from '../../mcp/workflow-executor.js';
+import { logger } from '../utils/logger.js';
+import { getErrorMessage } from '../../utils/error-utils.js';
+import { getFriendlyError } from '../../friendly-errors.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}]`;
+}
+/**
+ * Parse params from --params or --params-file.
+ */
+function parseParams(options) {
+    if (options.params) {
+        try {
+            return JSON.parse(options.params);
+        }
+        catch {
+            throw new Error(`Invalid JSON in --params: ${options.params}`);
+        }
+    }
+    if (options.paramsFile) {
+        const paramsFilePath = path.resolve(options.paramsFile);
+        if (!fs.existsSync(paramsFilePath)) {
+            throw new Error(`Params file not found: ${paramsFilePath}`);
+        }
+        try {
+            const content = fs.readFileSync(paramsFilePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch {
+            throw new Error(`Failed to parse params file: ${options.paramsFile}`);
+        }
+    }
+    return {};
+}
+/**
+ * Run a single compile + execute cycle.
+ * Returns true if both compile and run succeeded.
+ */
+async function compileAndRun(filePath, params, options) {
+    // Step 1: Compile
+    const compileOpts = {
+        format: options.format,
+        clean: options.clean,
+    };
+    try {
+        await compileCommand(filePath, compileOpts);
+        if (!options.json) {
+            logger.success('Compiled successfully');
+        }
+    }
+    catch (error) {
+        const errorMsg = getErrorMessage(error);
+        const errorObj = error;
+        if (errorObj.errors && Array.isArray(errorObj.errors)) {
+            logger.error('Compile failed:');
+            for (const err of errorObj.errors) {
+                const friendly = getFriendlyError(err);
+                if (friendly) {
+                    logger.error(`  ${friendly.title}: ${friendly.explanation}`);
+                    logger.info(`    How to fix: ${friendly.fix}`);
+                }
+                else {
+                    logger.error(`  - ${err.message}`);
+                }
+            }
+        }
+        else {
+            logger.error(`Compile failed: ${errorMsg}`);
+        }
+        return false;
+    }
+    // Step 2: Run
+    try {
+        const result = await executeWorkflowFromFile(filePath, params, {
+            workflowName: options.workflow,
+            production: options.production ?? false,
+            includeTrace: !options.production,
+        });
+        if (options.json) {
+            process.stdout.write(JSON.stringify({
+                success: true,
+                workflow: result.functionName,
+                executionTime: result.executionTime,
+                result: result.result,
+            }, null, 2) + '\n');
+        }
+        else {
+            logger.success(`Workflow "${result.functionName}" completed in ${result.executionTime}ms`);
+            logger.newline();
+            logger.section('Result');
+            logger.log(JSON.stringify(result.result, null, 2));
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMsg = getErrorMessage(error);
+        if (options.json) {
+            process.stdout.write(JSON.stringify({ success: false, error: errorMsg }, null, 2) + '\n');
+        }
+        else {
+            logger.error(`Run failed: ${errorMsg}`);
+        }
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Inngest Dev Mode
+// ---------------------------------------------------------------------------
+/**
+ * Check that required packages are installed.
+ */
+function checkDependency(pkg, cwd) {
+    try {
+        require.resolve(pkg, { paths: [cwd] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Generate the dev server entry file for Inngest.
+ */
+function generateDevServerEntry(inngestOutputPath, framework, port) {
+    const relImport = `./${path.basename(inngestOutputPath).replace(/\.ts$/, '.js')}`;
+    if (framework === 'express') {
+        return `import express from 'express';
+import { handler } from '${relImport}';
+
+const app = express();
+app.use(express.json());
+app.use('/api/inngest', handler);
+app.listen(${port}, () => {
+  console.log('Inngest dev server running on http://localhost:${port}');
+  console.log('Inngest endpoint: http://localhost:${port}/api/inngest');
+  console.log('');
+  console.log('Connect Inngest Dev Server:');
+  console.log('  npx inngest-cli@latest dev -u http://localhost:${port}/api/inngest');
+});
+`;
+    }
+    if (framework === 'hono') {
+        return `import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { handler } from '${relImport}';
+
+const app = new Hono();
+app.route('/api/inngest', handler);
+
+serve({ fetch: app.fetch, port: ${port} }, () => {
+  console.log('Inngest dev server running on http://localhost:${port}');
+  console.log('Inngest endpoint: http://localhost:${port}/api/inngest');
+  console.log('');
+  console.log('Connect Inngest Dev Server:');
+  console.log('  npx inngest-cli@latest dev -u http://localhost:${port}/api/inngest');
+});
+`;
+    }
+    // Default: express (most common for dev)
+    return generateDevServerEntry(inngestOutputPath, 'express', port);
+}
+/**
+ * Compile workflow to Inngest and start a local dev server.
+ */
+async function runInngestDevMode(filePath, options) {
+    const framework = options.framework ?? 'express';
+    const port = options.port ?? 3000;
+    const cwd = path.dirname(filePath);
+    // Check dependencies
+    const missingDeps = [];
+    if (!checkDependency('inngest', cwd))
+        missingDeps.push('inngest');
+    if (framework === 'express' && !checkDependency('express', cwd))
+        missingDeps.push('express');
+    if (framework === 'hono') {
+        if (!checkDependency('hono', cwd))
+            missingDeps.push('hono');
+        if (!checkDependency('@hono/node-server', cwd))
+            missingDeps.push('@hono/node-server');
+    }
+    if (missingDeps.length > 0) {
+        throw new Error(`Missing dependencies: ${missingDeps.join(', ')}. Install them with: npm install ${missingDeps.join(' ')}`);
+    }
+    // Set up temp directory for generated files
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fw-inngest-dev-'));
+    const inngestOutputPath = path.join(tmpDir, path.basename(filePath).replace(/\.ts$/, '.inngest.ts'));
+    let serverProcess = null;
+    const compileInngest = async () => {
+        try {
+            await compileInngestTarget(filePath, {
+                production: false,
+                workflowName: options.workflow,
+                serve: true,
+                framework: framework,
+                typedEvents: true,
+            });
+            // compileInngestTarget writes to filePath.replace(.ts, .inngest.ts)
+            // Copy it to our temp dir, then remove the source-adjacent file
+            const sourceOutput = filePath.replace(/\.ts$/, '.inngest.ts');
+            if (fs.existsSync(sourceOutput)) {
+                fs.copyFileSync(sourceOutput, inngestOutputPath);
+                try {
+                    fs.unlinkSync(sourceOutput);
+                }
+                catch { /* ignore */ }
+            }
+            return true;
+        }
+        catch (error) {
+            logger.error(`Inngest compilation failed: ${getErrorMessage(error)}`);
+            return false;
+        }
+    };
+    const startServer = () => {
+        // Generate dev server entry
+        const entryPath = path.join(tmpDir, 'dev-server.ts');
+        const entryCode = generateDevServerEntry(inngestOutputPath, framework, port);
+        fs.writeFileSync(entryPath, entryCode, 'utf8');
+        // Spawn tsx to run the server
+        serverProcess = spawn('npx', ['tsx', entryPath], {
+            cwd: path.dirname(filePath),
+            stdio: 'inherit',
+            shell: true,
+        });
+        serverProcess.on('error', (err) => {
+            logger.error(`Server process error: ${err.message}`);
+        });
+        serverProcess.on('exit', (code) => {
+            if (code !== null && code !== 0) {
+                logger.error(`Server exited with code ${code}`);
+            }
+            serverProcess = null;
+        });
+    };
+    const stopServer = () => {
+        if (serverProcess && !serverProcess.killed) {
+            serverProcess.kill('SIGTERM');
+            serverProcess = null;
+        }
+    };
+    const restartServer = async () => {
+        stopServer();
+        const ok = await compileInngest();
+        if (ok) {
+            startServer();
+        }
+    };
+    // Header
+    logger.section('Inngest Dev Mode');
+    logger.info(`File: ${path.basename(filePath)}`);
+    logger.info(`Framework: ${framework}`);
+    logger.info(`Port: ${port}`);
+    logger.newline();
+    // Initial compile + start
+    const ok = await compileInngest();
+    if (!ok) {
+        if (options.once)
+            return;
+        logger.info('Fix the errors above, then save the file to retry.');
+    }
+    else {
+        if (options.once)
+            return;
+        startServer();
+    }
+    // Watch for changes
+    logger.newline();
+    logger.success('Watching for file changes... (Ctrl+C to stop)');
+    const files = await glob(path.resolve(filePath), { absolute: true });
+    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('Recompiling and restarting server...');
+        logger.newline();
+        await restartServer();
+    });
+    // Cleanup
+    const sourceOutput = filePath.replace(/\.ts$/, '.inngest.ts');
+    const cleanup = () => {
+        logger.newline();
+        logger.info('Stopping Inngest dev mode...');
+        stopServer();
+        watcher.close();
+        // Clean up temp files and source-adjacent .inngest.ts
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+        try {
+            fs.unlinkSync(sourceOutput);
+        }
+        catch { /* ignore */ }
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    // Keep process alive
+    await new Promise(() => { });
+}
+// ---------------------------------------------------------------------------
+// Main Command
+// ---------------------------------------------------------------------------
+/**
+ * Dev command: watch + compile + run in a single loop.
+ */
+export async function devCommand(input, options = {}) {
+    const filePath = path.resolve(input);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    // Route to Inngest dev mode if target is inngest
+    if (options.target === 'inngest') {
+        return runInngestDevMode(filePath, options);
+    }
+    const params = parseParams(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)}`);
+        }
+        logger.newline();
+    }
+    // Initial compile + run
+    await compileAndRun(filePath, params, options);
+    // If --once, exit after first cycle
+    if (options.once) {
+        return;
+    }
+    if (!options.json) {
+        logger.newline();
+        logger.success('Watching for file changes... (Ctrl+C to stop)');
+    }
+    // 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) => {
+        if (!options.json) {
+            logger.newline();
+            logger.info(`${timestamp()} File changed: ${path.basename(file)}`);
+            logger.newline();
+        }
+        await compileAndRun(filePath, params, options);
+    });
+    // Handle process termination
+    const cleanup = () => {
+        if (!options.json) {
+            logger.newline();
+            logger.info('Stopping dev mode...');
+        }
+        watcher.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    // Keep process alive
+    await new Promise(() => {
+        // Never resolves - keeps process running
+    });
+}
+//# sourceMappingURL=dev.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Diagram command — generates SVG diagrams from workflow files.
+ */
+export interface DiagramCommandOptions {
+    theme?: 'dark' | 'light';
+    width?: number;
+    padding?: number;
+    showPortLabels?: boolean;
+    workflowName?: string;
+    output?: string;
+}
+export declare function diagramCommand(input: string, options?: DiagramCommandOptions): Promise<void>;
+//# sourceMappingURL=diagram.d.ts.map

package/dist/cli/commands/diagram.js

@@ -0,0 +1,33 @@
+/* eslint-disable no-console */
+/**
+ * Diagram command — generates SVG diagrams from workflow files.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileToSVG } from '../../diagram/index.js';
+import { logger } from '../utils/logger.js';
+import { getErrorMessage } from '../../utils/error-utils.js';
+export async function diagramCommand(input, options = {}) {
+    const { output, ...diagramOptions } = options;
+    const filePath = path.resolve(input);
+    if (!fs.existsSync(filePath)) {
+        logger.error(`File not found: ${filePath}`);
+        process.exit(1);
+    }
+    try {
+        const svg = fileToSVG(filePath, diagramOptions);
+        if (output) {
+            const outputPath = path.resolve(output);
+            fs.writeFileSync(outputPath, svg, 'utf-8');
+            logger.success(`Diagram written to ${outputPath}`);
+        }
+        else {
+            process.stdout.write(svg);
+        }
+    }
+    catch (error) {
+        logger.error(`Failed to generate diagram: ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=diagram.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Diff command - compares two workflow files semantically
+ */
+import type { TDiffFormat } from '../../diff/index.js';
+export interface DiffOptions {
+    format?: TDiffFormat;
+    workflowName?: string;
+    exitZero?: boolean;
+}
+export declare function diffCommand(file1: string, file2: string, options?: DiffOptions): Promise<void>;
+//# sourceMappingURL=diff.d.ts.map

package/dist/cli/commands/diff.js

@@ -0,0 +1,59 @@
+/**
+ * Diff command - compares two workflow files semantically
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseWorkflow } from '../../api/index.js';
+import { WorkflowDiffer, formatDiff } from '../../diff/index.js';
+import { logger } from '../utils/logger.js';
+import { getErrorMessage } from '../../utils/error-utils.js';
+export async function diffCommand(file1, file2, options = {}) {
+    const { format = 'text', workflowName, exitZero = false } = options;
+    const filePath1 = path.resolve(file1);
+    const filePath2 = path.resolve(file2);
+    // Validate files exist
+    if (!fs.existsSync(filePath1)) {
+        logger.error(`File not found: ${filePath1}`);
+        process.exit(1);
+    }
+    if (!fs.existsSync(filePath2)) {
+        logger.error(`File not found: ${filePath2}`);
+        process.exit(1);
+    }
+    try {
+        // Parse both workflows
+        const [result1, result2] = await Promise.all([
+            parseWorkflow(filePath1, { workflowName }),
+            parseWorkflow(filePath2, { workflowName }),
+        ]);
+        if (result1.errors.length > 0) {
+            logger.error(`Parse errors in ${file1}:`);
+            result1.errors.forEach((err) => logger.error(`  ${err}`));
+            process.exit(1);
+        }
+        if (result2.errors.length > 0) {
+            logger.error(`Parse errors in ${file2}:`);
+            result2.errors.forEach((err) => logger.error(`  ${err}`));
+            process.exit(1);
+        }
+        // Compare workflows
+        const diff = WorkflowDiffer.compare(result1.ast, result2.ast);
+        // Output based on format
+        if (diff.identical) {
+            logger.success('Workflows are identical');
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(formatDiff(diff, format));
+            // Exit with code 1 if there are differences (useful for CI)
+            if (!exitZero) {
+                process.exit(1);
+            }
+        }
+    }
+    catch (error) {
+        logger.error(`Failed to diff workflows: ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=diff.js.map

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

@@ -0,0 +1,57 @@
+/**
+ * Doctor command - validates project environment and configuration for flow-weaver compatibility
+ */
+import type { TModuleFormat } from '../../ast/types.js';
+export interface DoctorOptions {
+    json?: boolean;
+}
+/**
+ * Result of detecting the project's module format
+ */
+export interface ModuleFormatDetection {
+    format: TModuleFormat;
+    source: 'package.json' | 'tsconfig' | 'default';
+    details?: string;
+}
+export type CheckStatus = 'pass' | 'warn' | 'fail';
+export interface CheckResult {
+    name: string;
+    status: CheckStatus;
+    message: string;
+    fix?: string;
+    details?: string;
+}
+export interface DoctorReport {
+    ok: boolean;
+    checks: CheckResult[];
+    summary: {
+        pass: number;
+        warn: number;
+        fail: number;
+    };
+    moduleFormat: ModuleFormatDetection;
+}
+/**
+ * Strips single-line (//) and multi-line comments from JSON-like text,
+ * preserving string contents that may contain // or slash-star sequences.
+ */
+export declare function stripJsonComments(text: string): string;
+/**
+ * Detect the project's module format from package.json and tsconfig.json
+ */
+export declare function detectProjectModuleFormat(cwd: string): ModuleFormatDetection;
+export declare function checkNodeVersion(): CheckResult;
+export declare function checkTypeScriptVersion(cwd: string): CheckResult;
+export declare function checkPackageJsonType(cwd: string): CheckResult;
+export declare function checkTsconfigModule(cwd: string): CheckResult;
+export declare function checkTsconfigModuleResolution(cwd: string): CheckResult;
+export declare function checkFlowWeaverInstalled(cwd: string): CheckResult;
+export declare function checkFlowWeaverVersion(cwd: string): CheckResult;
+export declare function checkTypesNodeInstalled(cwd: string): CheckResult;
+export declare function checkTsxAvailable(cwd: string): CheckResult;
+export declare function checkProjectConfig(cwd: string): CheckResult;
+export declare function checkDeploymentManifest(cwd: string): CheckResult;
+export declare function checkDeploymentProfiles(cwd: string): CheckResult;
+export declare function runDoctorChecks(cwd: string): DoctorReport;
+export declare function doctorCommand(options?: DoctorOptions): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map