@synergenius/flow-weaver 0.17.1 → 0.17.3

package/dist/cli/commands/dev.js

@@ -3,14 +3,13 @@
  */
 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 { compileCommand } 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';
+import { devModeRegistry } from '../../generator/dev-mode-registry.js';
 function timestamp() {
     const now = new Date();
     const h = String(now.getHours()).padStart(2, '0');
@@ -124,204 +123,6 @@ async function compileAndRun(filePath, params, options) {
     }
 }
 // ---------------------------------------------------------------------------
-// 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();
-            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) => {
-        cycleSeparator(file);
-        logger.info('Recompiling and restarting server...');
-        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);
-    if (process.platform !== 'win32')
-        process.on('SIGTERM', cleanup);
-    // Keep process alive
-    await new Promise(() => { });
-}
-// ---------------------------------------------------------------------------
 // Main Command
 // ---------------------------------------------------------------------------
 /**
@@ -332,9 +133,14 @@ export async function devCommand(input, options = {}) {
     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);
+    // Delegate to a registered dev mode provider if one exists for the target
+    if (options.target) {
+        const provider = devModeRegistry.get(options.target);
+        if (provider) {
+            return provider.run(filePath, options);
+        }
+        const available = devModeRegistry.getNames();
+        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);
     if (!options.json) {

package/dist/cli/commands/doctor.js

@@ -455,7 +455,8 @@ export function checkTsxAvailable(cwd) {
 }
 // ── Config health checks ─────────────────────────────────────────────────────
 const VALID_FILE_TYPES = ['ts', 'tsx', 'js', 'jsx'];
-const VALID_TARGETS = ['lambda', 'vercel', 'cloudflare'];
+// Target validation is skipped — valid targets are discovered dynamically
+// from installed packs at export time.
 function readYaml(filePath) {
     try {
         const content = fs.readFileSync(filePath, 'utf8');
@@ -606,8 +607,10 @@ export function checkDeploymentProfiles(cwd) {
             continue;
         }
         const config = data;
-        if (config.target && !VALID_TARGETS.includes(config.target)) {
-            invalid.push(`${profile} (invalid target "${config.target}" — must be: ${VALID_TARGETS.join(', ')})`);
+        // Target names are validated at export time via the target registry.
+        // We only check that the value is a non-empty string here.
+        if (config.target && typeof config.target !== 'string') {
+            invalid.push(`${profile} (target must be a string)`);
         }
     }
     if (invalid.length > 0) {

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

@@ -2,7 +2,7 @@
  * Export command - generate serverless function handlers for deployment
  */
 export interface ExportOptions {
-    /** Target platform (lambda, vercel, cloudflare, inngest) */
+    /** Target platform (provided by installed packs) */
     target: string;
     /** Output directory */
     output: string;
@@ -20,7 +20,7 @@ export interface ExportOptions {
     workflows?: string;
     /** Include API documentation routes (/docs and /openapi.json) */
     docs?: boolean;
-    /** Use deep generator with per-node Inngest steps for durability (inngest target only) */
+    /** Use deep generator with per-node durable steps */
     durableSteps?: boolean;
 }
 /**
@@ -31,26 +31,17 @@ export interface ExportOptions {
  *
  * @example
  * ```bash
- * # Export for Vercel
- * flow-weaver export workflow.ts --target vercel --output api/
- *
- * # Export for AWS Lambda
- * flow-weaver export workflow.ts --target lambda --output dist/lambda/
- *
- * # Export for Cloudflare Workers
- * flow-weaver export workflow.ts --target cloudflare --output workers/
+ * # Export for a target (install the corresponding pack first)
+ * flow-weaver export workflow.ts --target <target> --output dist/
  *
  * # Export specific workflow from multi-workflow file
- * flow-weaver export multi-workflow.ts --target vercel --output api/ --workflow calculate
- *
- * # Export all workflows as a single service (multi-workflow mode)
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi
+ * flow-weaver export multi-workflow.ts --target <target> --output api/ --workflow calculate
  *
- * # Export specific workflows from a file as a service
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi --workflows "workflowA,workflowB"
+ * # Export all workflows as a single service
+ * flow-weaver export workflows.ts --target <target> --output dist/ --multi
  *
  * # Export with API documentation routes
- * flow-weaver export workflow.ts --target lambda --output dist/ --docs
+ * flow-weaver export workflow.ts --target <target> --output dist/ --docs
  * ```
  */
 export declare function exportCommand(input: string, options: ExportOptions): Promise<void>;

package/dist/cli/commands/export.js

@@ -11,32 +11,23 @@ import { logger } from '../utils/logger.js';
  *
  * @example
  * ```bash
- * # Export for Vercel
- * flow-weaver export workflow.ts --target vercel --output api/
- *
- * # Export for AWS Lambda
- * flow-weaver export workflow.ts --target lambda --output dist/lambda/
- *
- * # Export for Cloudflare Workers
- * flow-weaver export workflow.ts --target cloudflare --output workers/
+ * # Export for a target (install the corresponding pack first)
+ * flow-weaver export workflow.ts --target <target> --output dist/
  *
  * # Export specific workflow from multi-workflow file
- * flow-weaver export multi-workflow.ts --target vercel --output api/ --workflow calculate
- *
- * # Export all workflows as a single service (multi-workflow mode)
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi
+ * flow-weaver export multi-workflow.ts --target <target> --output api/ --workflow calculate
  *
- * # Export specific workflows from a file as a service
- * flow-weaver export workflows.ts --target lambda --output dist/ --multi --workflows "workflowA,workflowB"
+ * # Export all workflows as a single service
+ * flow-weaver export workflows.ts --target <target> --output dist/ --multi
  *
  * # Export with API documentation routes
- * flow-weaver export workflow.ts --target lambda --output dist/ --docs
+ * flow-weaver export workflow.ts --target <target> --output dist/ --docs
  * ```
  */
 export async function exportCommand(input, options) {
     // Validate target is provided
     if (!options.target) {
-        throw new Error('--target is required. Install a target pack (e.g. npm install flowweaver-pack-lambda)');
+        throw new Error('--target is required. Install a target pack first.');
     }
     const isDryRun = options.dryRun ?? false;
     const t = logger.timer();
@@ -64,7 +55,7 @@ export async function exportCommand(input, options) {
         logger.info('Include docs: Yes (/docs and /openapi.json routes)');
     }
     if (options.durableSteps) {
-        logger.info('Durable steps: Yes (per-node step.run for Inngest)');
+        logger.info('Durable steps: Yes');
     }
     if (isDryRun) {
         logger.info('Mode: DRY RUN (no files will be written)');

package/dist/cli/commands/init-personas.d.ts

@@ -3,7 +3,7 @@
  * Types, use-case mappings, template selection, and post-scaffold output.
  */
 export type PersonaId = 'nocode' | 'vibecoder' | 'lowcode' | 'expert';
-export type UseCaseId = 'data' | 'ai' | 'api' | 'automation' | 'cicd' | 'minimal';
+export type UseCaseId = 'data' | 'ai' | 'api' | 'automation' | 'minimal';
 export declare const PERSONA_CHOICES: {
     value: PersonaId;
     name: string;
@@ -20,13 +20,22 @@ export interface UseCaseMapping {
     default: string;
     all: string[];
 }
-export declare const USE_CASE_TEMPLATES: Record<UseCaseId, UseCaseMapping>;
+export declare const USE_CASE_TEMPLATES: Record<string, UseCaseMapping>;
+/**
+ * Register a use case contributed by a pack.
+ * Adds the use case choice and template mapping so it appears in fw init.
+ */
+export declare function registerPackUseCase(useCase: {
+    id: string;
+    name: string;
+    description: string;
+}, templates: string[]): void;
 /**
  * Select the template for a given persona and use-case.
  * For lowcode, returns the full list when the category has multiple templates.
  * For nocode/vibecoder, always returns the single default.
  */
-export declare function selectTemplateForPersona(persona: PersonaId, useCase: UseCaseId): {
+export declare function selectTemplateForPersona(persona: PersonaId, useCase: UseCaseId | string): {
     template: string;
     choices?: string[];
 };

package/dist/cli/commands/init-personas.js

@@ -4,7 +4,7 @@
  */
 import { execSync } from 'child_process';
 import { logger } from '../utils/logger.js';
-import { workflowTemplates } from '../templates/index.js';
+import { getAllWorkflowTemplates } from '../templates/index.js';
 import { buildContext } from '../../context/index.js';
 // ── Prompt choices ───────────────────────────────────────────────────────────
 export const PERSONA_CHOICES = [
@@ -25,7 +25,6 @@ export const USE_CASE_CHOICES = [
     { value: 'ai', name: 'AI agent', description: 'LLM with tools, reasoning, or retrieval' },
     { value: 'api', name: 'API / webhook', description: 'HTTP endpoints and integrations' },
     { value: 'automation', name: 'Automation', description: 'Conditional logic, error handling, routing' },
-    { value: 'cicd', name: 'CI/CD pipeline', description: 'Test, build, and deploy workflows' },
     { value: 'minimal', name: 'Something else', description: 'Start with a minimal template' },
 ];
 export const USE_CASE_TEMPLATES = {
@@ -33,9 +32,33 @@ export const USE_CASE_TEMPLATES = {
     ai: { default: 'ai-agent', all: ['ai-agent', 'ai-react', 'ai-rag', 'ai-chat'] },
     api: { default: 'webhook', all: ['webhook'] },
     automation: { default: 'conditional', all: ['conditional', 'error-handler'] },
-    cicd: { default: 'cicd-test-deploy', all: ['cicd-test-deploy', 'cicd-docker', 'cicd-multi-env', 'cicd-matrix'] },
     minimal: { default: 'sequential', all: ['sequential'] },
 };
+/**
+ * Register a use case contributed by a pack.
+ * Adds the use case choice and template mapping so it appears in fw init.
+ */
+export function registerPackUseCase(useCase, templates) {
+    // Add to choices if not already present
+    if (!USE_CASE_CHOICES.some((c) => c.value === useCase.id)) {
+        // Insert before "minimal" (last entry)
+        const minimalIdx = USE_CASE_CHOICES.findIndex((c) => c.value === 'minimal');
+        const entry = { value: useCase.id, name: useCase.name, description: useCase.description };
+        if (minimalIdx >= 0) {
+            USE_CASE_CHOICES.splice(minimalIdx, 0, entry);
+        }
+        else {
+            USE_CASE_CHOICES.push(entry);
+        }
+    }
+    // Add template mapping
+    if (!USE_CASE_TEMPLATES[useCase.id] && templates.length > 0) {
+        USE_CASE_TEMPLATES[useCase.id] = {
+            default: templates[0],
+            all: templates,
+        };
+    }
+}
 /**
  * Select the template for a given persona and use-case.
  * For lowcode, returns the full list when the category has multiple templates.
@@ -57,7 +80,7 @@ export function selectTemplateForPersona(persona, useCase) {
  */
 export function getTemplateSubChoices(templateIds) {
     return templateIds.map((id) => {
-        const tmpl = workflowTemplates.find((t) => t.id === id);
+        const tmpl = getAllWorkflowTemplates().find((t) => t.id === id);
         return {
             value: id,
             name: id,

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

@@ -4,7 +4,7 @@
  */
 import type { ToolId } from './mcp-setup.js';
 import type { TModuleFormat } from '../../ast/types.js';
-import type { PersonaId, UseCaseId } from './init-personas.js';
+import type { PersonaId } from './init-personas.js';
 export interface InitOptions {
     name?: string;
     template?: string;
@@ -28,7 +28,7 @@ export interface InitConfig {
     git: boolean;
     force: boolean;
     persona: PersonaId;
-    useCase?: UseCaseId;
+    useCase?: string;
     /** Free-text description when user picked "Something else" */
     useCaseDescription?: string;
     mcp: boolean;

package/dist/cli/commands/init.js

@@ -10,7 +10,7 @@ import input from '@inquirer/input';
 import select, { Separator } from '@inquirer/select';
 import confirm from '@inquirer/confirm';
 import { ExitPromptError } from '@inquirer/core';
-import { getWorkflowTemplate, workflowTemplates } from '../templates/index.js';
+import { getWorkflowTemplate, getAllWorkflowTemplates } from '../templates/index.js';
 import { logger } from '../utils/logger.js';
 import { compileCommand } from './compile.js';
 import { runMcpSetupFromInit, CLI_TOOL_BINARY, detectCliTools } from './mcp-setup.js';
@@ -37,9 +37,11 @@ export function toWorkflowName(projectName) {
 export function isNonInteractive() {
     return !process.stdin.isTTY;
 }
-const VALID_TEMPLATES = workflowTemplates.map((t) => t.id);
+// Dynamic: includes core templates plus any registered by extensions
+const VALID_TEMPLATES = getAllWorkflowTemplates().map((t) => t.id);
 const VALID_PERSONAS = ['nocode', 'vibecoder', 'lowcode', 'expert'];
-const VALID_USE_CASES = ['data', 'ai', 'api', 'automation', 'cicd', 'minimal'];
+// Dynamic: includes core use cases plus any registered by extensions
+const VALID_USE_CASES = USE_CASE_CHOICES.map((c) => c.value);
 // ── Config resolution (prompts) ──────────────────────────────────────────────
 export async function resolveInitConfig(dirArg, options) {
     const skipPrompts = options.yes || isNonInteractive();
@@ -124,18 +126,10 @@ export async function resolveInitConfig(dirArg, options) {
                     { value: 'ai-react', name: 'ai-react', description: 'ReAct pattern' },
                     { value: 'ai-rag', name: 'ai-rag', description: 'Retrieval-Augmented Generation' },
                     { value: 'ai-chat', name: 'ai-chat', description: 'Conversational AI' },
-                    new Separator('── Durable ──'),
-                    { value: 'ai-agent-durable', name: 'ai-agent-durable', description: 'Durable agent with approval gate' },
-                    { value: 'ai-pipeline-durable', name: 'ai-pipeline-durable', description: 'Durable data pipeline' },
                     new Separator('── Integration ──'),
                     { value: 'webhook', name: 'webhook', description: 'HTTP webhook handler' },
                     new Separator('── Utility ──'),
                     { value: 'error-handler', name: 'error-handler', description: 'Error handling and recovery' },
-                    new Separator('── CI/CD ──'),
-                    { value: 'cicd-test-deploy', name: 'cicd-test-deploy', description: 'Test and deploy pipeline' },
-                    { value: 'cicd-docker', name: 'cicd-docker', description: 'Docker build and push' },
-                    { value: 'cicd-multi-env', name: 'cicd-multi-env', description: 'Multi-environment deploy' },
-                    { value: 'cicd-matrix', name: 'cicd-matrix', description: 'Matrix build strategy' },
                 ],
                 default: 'sequential',
             });