@synergenius/flow-weaver 0.17.0 → 0.17.2

package/dist/extensions/inngest/dev-mode.js

@@ -0,0 +1,213 @@
+/**
+ * Inngest dev mode provider.
+ *
+ * Compiles a workflow to an Inngest function, generates a local dev server
+ * entry (express or hono), and watches for file 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 { compileCustomTarget } from '../../cli/commands/compile.js';
+import { logger } from '../../cli/utils/logger.js';
+import { getErrorMessage } from '../../utils/error-utils.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}`;
+}
+function cycleSeparator(file) {
+    const ts = timestamp();
+    const pad = '─'.repeat(40);
+    logger.log(`\n  ${logger.dim(`─── ${ts} ${pad}`)}`);
+    if (file) {
+        logger.log(`  ${logger.dim('File changed:')} ${path.basename(file)}`);
+    }
+}
+function checkDependency(pkg, cwd) {
+    try {
+        require.resolve(pkg, { paths: [cwd] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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
+    return generateDevServerEntry(inngestOutputPath, 'express', port);
+}
+export 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 compileCustomTarget('inngest', filePath, {
+                production: false,
+                workflowName: options.workflow,
+                serve: true,
+                framework: framework,
+                typedEvents: true,
+            });
+            // compileCustomTarget 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(`Compilation failed: ${getErrorMessage(error)}`);
+            return false;
+        }
+    };
+    const startServer = () => {
+        const entryPath = path.join(tmpDir, 'dev-server.ts');
+        const entryCode = generateDevServerEntry(inngestOutputPath, framework, port);
+        fs.writeFileSync(entryPath, entryCode, 'utf8');
+        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 dev mode...');
+        stopServer();
+        watcher.close();
+        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(() => { });
+}
+//# sourceMappingURL=dev-mode.js.map

package/dist/{generator/inngest.d.ts → extensions/inngest/generator.d.ts}

@@ -14,7 +14,7 @@
  *
  * @module generator/inngest
  */
-import type { TNodeTypeAST, TWorkflowAST } from '../ast/types.js';
+import type { TNodeTypeAST, TWorkflowAST } from '../../ast/types.js';
 export interface InngestGenerationOptions {
     /** Omit debug instrumentation for smaller output */
     production?: boolean;
@@ -50,4 +50,4 @@ export interface InngestGenerationOptions {
  * @returns Complete TypeScript source code string
  */
 export declare function generateInngestFunction(workflow: TWorkflowAST, nodeTypes: TNodeTypeAST[], options?: InngestGenerationOptions): string;
-//# sourceMappingURL=inngest.d.ts.map
+//# sourceMappingURL=generator.d.ts.map

package/dist/{generator/inngest.js → extensions/inngest/generator.js}

@@ -14,9 +14,9 @@
  *
  * @module generator/inngest
  */
-import { toValidIdentifier } from './code-utils.js';
-import { buildControlFlowGraph, detectBranchingChains, findAllBranchingNodes, findNodesInBranch, performKahnsTopologicalSort, isPerPortScopedChild, } from './control-flow.js';
-import { RESERVED_PORT_NAMES, isStartNode, isExitNode, isExecutePort, isSuccessPort, isFailurePort, } from '../constants.js';
+import { toValidIdentifier } from '../../generator/code-utils.js';
+import { buildControlFlowGraph, detectBranchingChains, findAllBranchingNodes, findNodesInBranch, performKahnsTopologicalSort, isPerPortScopedChild, } from '../../generator/control-flow.js';
+import { RESERVED_PORT_NAMES, isStartNode, isExitNode, isExecutePort, isSuccessPort, isFailurePort, } from '../../constants.js';
 // ---------------------------------------------------------------------------
 // Built-in Node Detection
 // ---------------------------------------------------------------------------
@@ -1173,4 +1173,4 @@ export function generateInngestFunction(workflow, nodeTypes, options) {
     }
     return lines.join('\n');
 }
-//# sourceMappingURL=inngest.js.map
+//# sourceMappingURL=generator.js.map

package/dist/extensions/inngest/index.d.ts

@@ -0,0 +1,2 @@
+export { generateInngestFunction, type InngestGenerationOptions } from './generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/inngest/index.js

@@ -0,0 +1,2 @@
+export { generateInngestFunction } from './generator.js';
+//# sourceMappingURL=index.js.map

package/dist/extensions/inngest/register.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Inngest extension self-registration module.
+ * Loaded as a side-effect import from src/extensions/index.ts.
+ */
+export {};
+//# sourceMappingURL=register.d.ts.map

package/dist/extensions/inngest/register.js

@@ -0,0 +1,23 @@
+/**
+ * Inngest extension self-registration module.
+ * Loaded as a side-effect import from src/extensions/index.ts.
+ */
+import { compileTargetRegistry } from '../../generator/compile-target-registry.js';
+import { devModeRegistry } from '../../generator/dev-mode-registry.js';
+import { registerWorkflowTemplates } from '../../cli/templates/index.js';
+import { generateInngestFunction } from './generator.js';
+import { runInngestDevMode } from './dev-mode.js';
+import { aiAgentDurableTemplate } from './templates/ai-agent-durable.js';
+import { aiPipelineDurableTemplate } from './templates/ai-pipeline-durable.js';
+compileTargetRegistry.register({
+    name: 'inngest',
+    compile(workflow, nodeTypes, options) {
+        return generateInngestFunction(workflow, nodeTypes, options);
+    },
+});
+devModeRegistry.register({
+    name: 'inngest',
+    run: runInngestDevMode,
+});
+registerWorkflowTemplates([aiAgentDurableTemplate, aiPipelineDurableTemplate]);
+//# sourceMappingURL=register.js.map

package/dist/extensions/inngest/templates/ai-agent-durable.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Durable AI Agent Template
+ * Linear agent pipeline with durability annotations.
+ * Each node maps to a checkpointed step when compiled to a durable target.
+ */
+import type { WorkflowTemplate } from '../../../cli/templates/index.js';
+export declare const aiAgentDurableTemplate: WorkflowTemplate;
+//# sourceMappingURL=ai-agent-durable.d.ts.map

package/dist/{cli/templates/workflows → extensions/inngest/templates}/ai-agent-durable.js

@@ -1,6 +1,6 @@
-import { getProviderCode } from '../providers/index.js';
-import { aiConfigSchema } from './ai-agent.js';
-import { LLM_CORE_TYPES, LLM_MOCK_PROVIDER_WITH_TOOLS } from '../shared/llm-types.js';
+import { getProviderCode } from '../../../cli/templates/providers/index.js';
+import { aiConfigSchema } from '../../../cli/templates/workflows/ai-agent.js';
+import { LLM_CORE_TYPES, LLM_MOCK_PROVIDER_WITH_TOOLS } from '../../../cli/templates/shared/llm-types.js';
 export const aiAgentDurableTemplate = {
     id: 'ai-agent-durable',
     name: 'Durable AI Agent',
@@ -24,11 +24,11 @@ ${LLM_MOCK_PROVIDER_WITH_TOOLS}
 // Durable AI Agent
 // ============================================================
 //
-// Each node becomes a checkpointed step when compiled to Inngest.
-// If a step fails, it retries from that step — not from scratch.
+// Each node becomes a checkpointed step when compiled to a durable target.
+// If a step fails, it retries from that step, not from scratch.
 //
 // Compile:  flow-weaver compile <file>
-// Export:   fw export --target inngest
+// Export:   fw export --target <target>
 //
 // Flow: classify → executeTool → requestApproval → respond
 
@@ -75,7 +75,7 @@ const TOOL_IMPLEMENTATIONS: Record<string, ToolFn> = {
  * APPROVAL BACKEND (mock — replace with real backend)
  * ============================================================
  *
- * On Inngest targets, this node compiles to step.waitForEvent().
+ * On durable targets, this node compiles to a platform-native wait primitive.
  * The function pauses (zero compute cost) until an approval event arrives.
  */
 
@@ -289,7 +289,7 @@ async function respond(
 
 /**
  * Durable AI Agent — linear pipeline with tool calling and human approval.
- * Each node becomes a checkpointed step when compiled to Inngest.
+ * Each node becomes a checkpointed step when compiled to a durable target.
  *
  * @flowWeaver workflow
  * @trigger event="agent/request"

package/dist/{cli/templates/workflows → extensions/inngest/templates}/ai-pipeline-durable.d.ts

@@ -1,8 +1,8 @@
 /**
  * Durable AI Pipeline Template
- * Sequential data processing pipeline with durability annotations for Inngest compilation.
+ * Sequential data processing pipeline with durability annotations.
  * Each node maps to a checkpointed step — if step 3 fails, it retries from step 3, not from scratch.
  */
-import type { WorkflowTemplate } from '../index.js';
+import type { WorkflowTemplate } from '../../../cli/templates/index.js';
 export declare const aiPipelineDurableTemplate: WorkflowTemplate;
 //# sourceMappingURL=ai-pipeline-durable.d.ts.map

package/dist/{cli/templates/workflows → extensions/inngest/templates}/ai-pipeline-durable.js

@@ -1,6 +1,6 @@
-import { getProviderCode } from '../providers/index.js';
-import { aiConfigSchema } from './ai-agent.js';
-import { LLM_CORE_TYPES, LLM_MOCK_PROVIDER } from '../shared/llm-types.js';
+import { getProviderCode } from '../../../cli/templates/providers/index.js';
+import { aiConfigSchema } from '../../../cli/templates/workflows/ai-agent.js';
+import { LLM_CORE_TYPES, LLM_MOCK_PROVIDER } from '../../../cli/templates/shared/llm-types.js';
 export const aiPipelineDurableTemplate = {
     id: 'ai-pipeline-durable',
     name: 'Durable AI Pipeline',
@@ -24,11 +24,11 @@ ${LLM_MOCK_PROVIDER}
 // Durable Data Pipeline
 // ============================================================
 //
-// Each node becomes a checkpointed step when compiled to Inngest.
-// If step 3 fails, it retries from step 3 — not from scratch.
+// Each node becomes a checkpointed step when compiled to a durable target.
+// If step 3 fails, it retries from step 3, not from scratch.
 //
 // Compile:  flow-weaver compile <file>
-// Export:   fw export --target inngest
+// Export:   fw export --target <target>
 //
 // Flow: fetchData → extract (LLM) → validate → save
 //                                      ↓ onFailure
@@ -277,7 +277,7 @@ async function saveResult(
 
 /**
  * Durable Data Pipeline — sequential fetch, extract, validate, save.
- * Each node becomes a checkpointed step when compiled to Inngest.
+ * Each node becomes a checkpointed step when compiled to a durable target.
  *
  * @flowWeaver workflow
  * @trigger event="pipeline/start"

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.17.0";
+export declare const VERSION = "0.17.2";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.17.0';
+export const VERSION = '0.17.2';
 //# sourceMappingURL=generated-version.js.map

package/dist/generator/compile-target-registry.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Extension point for custom compile targets.
+ *
+ * Extensions and packs register their compile targets here.
+ * The compile command and MCP tool look up targets from this registry.
+ */
+import type { TNodeTypeAST, TWorkflowAST } from '../ast/types.js';
+export interface CompileTarget {
+    name: string;
+    compile(workflow: TWorkflowAST, nodeTypes: TNodeTypeAST[], options: Record<string, unknown>): string;
+}
+declare class CompileTargetRegistry {
+    private targets;
+    register(target: CompileTarget): void;
+    get(name: string): CompileTarget | undefined;
+    getNames(): string[];
+}
+export declare const compileTargetRegistry: CompileTargetRegistry;
+export {};
+//# sourceMappingURL=compile-target-registry.d.ts.map

package/dist/generator/compile-target-registry.js

@@ -0,0 +1,20 @@
+/**
+ * Extension point for custom compile targets.
+ *
+ * Extensions and packs register their compile targets here.
+ * The compile command and MCP tool look up targets from this registry.
+ */
+class CompileTargetRegistry {
+    targets = new Map();
+    register(target) {
+        this.targets.set(target.name, target);
+    }
+    get(name) {
+        return this.targets.get(name);
+    }
+    getNames() {
+        return [...this.targets.keys()];
+    }
+}
+export const compileTargetRegistry = new CompileTargetRegistry();
+//# sourceMappingURL=compile-target-registry.js.map

package/dist/generator/dev-mode-registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Extension point for custom dev mode providers.
+ *
+ * Extensions register dev mode handlers here so the dev command can
+ * start target-specific dev servers without hardcoding any pack logic.
+ */
+export interface DevModeOptions {
+    workflow?: string;
+    framework?: string;
+    port?: number;
+    production?: boolean;
+    once?: boolean;
+    json?: boolean;
+}
+export interface DevModeProvider {
+    name: string;
+    run(filePath: string, options: DevModeOptions): Promise<void>;
+}
+declare class DevModeRegistry {
+    private providers;
+    register(provider: DevModeProvider): void;
+    get(name: string): DevModeProvider | undefined;
+    getNames(): string[];
+}
+export declare const devModeRegistry: DevModeRegistry;
+export {};
+//# sourceMappingURL=dev-mode-registry.d.ts.map

package/dist/generator/dev-mode-registry.js

@@ -0,0 +1,20 @@
+/**
+ * Extension point for custom dev mode providers.
+ *
+ * Extensions register dev mode handlers here so the dev command can
+ * start target-specific dev servers without hardcoding any pack logic.
+ */
+class DevModeRegistry {
+    providers = new Map();
+    register(provider) {
+        this.providers.set(provider.name, provider);
+    }
+    get(name) {
+        return this.providers.get(name);
+    }
+    getNames() {
+        return [...this.providers.keys()];
+    }
+}
+export const devModeRegistry = new DevModeRegistry();
+//# sourceMappingURL=dev-mode-registry.js.map

package/dist/index.d.ts

@@ -58,6 +58,10 @@
 export * from './api/index.js';
 export { parser, resolveNpmNodeTypes } from './parser.js';
 export type { TExternalNodeType } from './parser.js';
+export { TagHandlerRegistry } from './parser/tag-registry.js';
+export type { TTagHandlerFn, TTagHandlerContext } from './parser/tag-registry.js';
+export { ValidationRuleRegistry } from './validation/rule-registry.js';
+export type { TValidationRuleSet } from './validation/rule-registry.js';
 export type { TConnectionAST, TNodeTypeAST, TNodeInstanceAST, TNodeInstanceConfig, TPortConfig, TWorkflowAST, TPortReference, TPortDefinition, TDataType, TExecuteWhen, TBranchingStrategy, TSerializableValue, TSerializableObject, TSerializableArray, TImportDeclaration, TImportSpecifier, TSourceLocation, TValidationError, TAnalysisResult, TControlFlowGraph, TControlFlowEdge, TBranchingNodeInfo, TBranchRegion, TMergeNodeInfo, TWorkflowMetadata, TNodeMetadata, TConnectionMetadata, TASTTransformer, TASTVisitor, TParseOptions, TValidationRule, TGenerateOptions, TCompileResult, TCompilationMetadata, TNodeTypeDefaultConfig, TNodeTypePort, TPortDirection, TNodeParent, TPullExecutionConfig, TWorkflowFileExtension, TPortPlacement, TPortUI, TNodeTypeUI, TNodeUI, TWorkFlowFunctionUI, TPortType, } from './ast/types.js';
 export { WorkflowBuilder, NodeTypeBuilder, NodeInstanceBuilder, ConnectionBuilder, } from './ast/builder.js';
 export { portRef, port, workflow, nodeType, nodeInstance } from './ast/builder.js';

package/dist/index.js

@@ -59,6 +59,9 @@
 export * from './api/index.js';
 // Parser (for advanced use - clearing import cache)
 export { parser, resolveNpmNodeTypes } from './parser.js';
+// Extension registries
+export { TagHandlerRegistry } from './parser/tag-registry.js';
+export { ValidationRuleRegistry } from './validation/rule-registry.js';
 // AST Builders (for programmatic AST construction)
 export { WorkflowBuilder, NodeTypeBuilder, NodeInstanceBuilder, ConnectionBuilder, } from './ast/builder.js';
 export { portRef, port, workflow, nodeType, nodeInstance } from './ast/builder.js';