@synergenius/flow-weaver 0.13.2 → 0.14.0

package/dist/marketplace/types.d.ts

@@ -26,6 +26,8 @@ export type TMarketplaceManifest = {
     workflows: TManifestWorkflow[];
     /** Patterns included in this package */
     patterns: TManifestPattern[];
+    /** Export targets provided by this package */
+    exportTargets?: TManifestExportTarget[];
     /** External dependency information */
     dependencies?: {
         /** Flow Weaver peer dependency constraints */
@@ -34,6 +36,17 @@ export type TMarketplaceManifest = {
         npm?: Record<string, string>;
     };
 };
+/** An export target provided by a marketplace package. */
+export type TManifestExportTarget = {
+    /** Target identifier (e.g. "lambda", "azure-pipelines") */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Relative path to the compiled JS file that exports the target class */
+    file: string;
+    /** Named export from the file (default: "default") */
+    exportName?: string;
+};
 export type TManifestPort = {
     dataType: TDataType;
     description?: string;

package/dist/marketplace/validator.js

@@ -47,10 +47,29 @@ function validatePackageJson(pkg, directory) {
 // ── Manifest-level rules ─────────────────────────────────────────────────────
 function validateManifestContents(manifest) {
     const issues = [];
-    const totalUnits = manifest.nodeTypes.length + manifest.workflows.length + manifest.patterns.length;
+    const totalUnits = manifest.nodeTypes.length + manifest.workflows.length + manifest.patterns.length +
+        (manifest.exportTargets?.length ?? 0);
     // PKG-006: Must contain at least one unit
     if (totalUnits === 0) {
-        issues.push(issue('PKG-006', 'error', 'Package must contain at least one node type, workflow, or pattern'));
+        issues.push(issue('PKG-006', 'error', 'Package must contain at least one node type, workflow, pattern, or export target'));
+    }
+    // TGT-001: Export target entries must have name and file
+    for (const et of manifest.exportTargets ?? []) {
+        if (!et.name) {
+            issues.push(issue('TGT-001', 'error', 'Export target entry must have a "name"'));
+        }
+        if (!et.file) {
+            issues.push(issue('TGT-001', 'error', `Export target "${et.name || '(unnamed)'}" must have a "file"`));
+        }
+    }
+    // TGT-002: Export target names must be unique within the package
+    const etNames = new Set();
+    for (const et of manifest.exportTargets ?? []) {
+        if (et.name && etNames.has(et.name)) {
+            issues.push(issue('TGT-002', 'error', `Duplicate export target name: "${et.name}"`));
+        }
+        if (et.name)
+            etNames.add(et.name);
     }
     // UNIT-002: Node type names must be unique within the package
     const ntNames = new Set();

package/dist/mcp/tools-export.js

@@ -14,8 +14,8 @@ export function registerExportTools(mcp) {
     mcp.tool('fw_export', 'Export workflows as serverless deployments. Generates handler code, platform config, and deploy instructions.', {
         filePath: z.string().describe('Path to the workflow .ts file'),
         target: z
-            .enum(['lambda', 'vercel', 'cloudflare', 'inngest'])
-            .describe('Deployment target platform'),
+            .string()
+            .describe('Deployment target platform (e.g. lambda, vercel, cloudflare, inngest, github-actions, gitlab-ci). Run with --list-targets to see installed targets.'),
         outputDir: z.string().describe('Output directory for generated files'),
         serviceName: z
             .string()
@@ -54,7 +54,16 @@ export function registerExportTools(mcp) {
             catch {
                 return makeErrorResult('FILE_NOT_FOUND', `File not found: ${filePath}`);
             }
-            // 2. Parse the file to discover workflows and node types
+            // 2. Discover targets from installed packs
+            const registry = await createTargetRegistry(process.cwd());
+            const exportTarget = registry.get(args.target);
+            if (!exportTarget) {
+                const available = registry.getNames();
+                return makeErrorResult('INVALID_TARGET', available.length === 0
+                    ? `No export targets installed. Install a target pack (e.g. npm install flowweaver-pack-${args.target})`
+                    : `Unknown target: "${args.target}". Installed: ${available.join(', ')}`);
+            }
+            // 3. Parse the file to discover workflows and node types
             let parseResult;
             try {
                 parseResult = await parseWorkflow(filePath, { nodeTypesOnly: false });
@@ -77,21 +86,50 @@ export function registerExportTools(mcp) {
                     return makeErrorResult('PARSE_ERROR', `Parse errors in ${filePath}: ${parseResult.errors.join('; ')}`);
                 }
             }
-            // 3. Get the export target
-            const registry = createTargetRegistry();
-            const exportTarget = registry.get(args.target);
-            if (!exportTarget) {
-                return makeErrorResult('INVALID_TARGET', `Unknown target: ${args.target}. Supported: lambda, vercel, cloudflare, inngest`);
-            }
+            // CI/CD targets use generate() directly — they read the AST, not compiled code
             if (!exportTarget.generateBundle) {
-                return makeErrorResult('INVALID_TARGET', `Target ${args.target} does not support bundle export`);
+                const serviceName = args.serviceName || path.basename(filePath, '.ts').replace(/[^a-zA-Z0-9-]/g, '-');
+                const artifacts = await exportTarget.generate({
+                    sourceFile: filePath,
+                    workflowName: args.workflows?.[0] || serviceName,
+                    displayName: serviceName,
+                    outputDir,
+                    production: true,
+                });
+                // Write files if not preview
+                if (!preview) {
+                    await fs.promises.mkdir(outputDir, { recursive: true });
+                    for (const file of artifacts.files) {
+                        const fullPath = path.join(outputDir, file.relativePath);
+                        await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
+                        await fs.promises.writeFile(fullPath, file.content, 'utf-8');
+                    }
+                }
+                const instructions = exportTarget.getDeployInstructions(artifacts);
+                return makeToolResult({
+                    preview,
+                    target: args.target,
+                    serviceName,
+                    outputDir,
+                    files: artifacts.files.map((f) => ({
+                        path: f.relativePath,
+                        type: f.type,
+                        size: f.content.length,
+                    })),
+                    instructions: {
+                        title: instructions.title,
+                        steps: instructions.steps,
+                        prerequisites: instructions.prerequisites,
+                    },
+                    summary: preview
+                        ? `Preview: ${artifacts.files.length} files would be generated in ${outputDir}`
+                        : `Exported ${artifacts.files.length} files to ${outputDir}`,
+                });
             }
             // 4. Build workflow and node type lists
-            // parseResult.allWorkflows has all TWorkflowAST[] from the file;
-            // each workflow's nodeTypes are in workflow.nodeTypes (TNodeTypeAST[])
             const allWorkflows = parseResult.allWorkflows || [];
             const allNodeTypes = allWorkflows.flatMap((w) => w.nodeTypes || []);
-            // Deduplicate node types by name (same type may appear in multiple workflows)
+            // Deduplicate node types by name
             const uniqueNodeTypes = [
                 ...new Map(allNodeTypes.map((nt) => [nt.name, nt])).values(),
             ];
@@ -133,7 +171,11 @@ export function registerExportTools(mcp) {
                 outputDir,
                 production: true,
                 includeDocs,
-                targetOptions: args.durableSteps ? { durableSteps: true } : undefined,
+                targetOptions: {
+                    ...(args.durableSteps && { durableSteps: true }),
+                    // Pass @deploy config from workflow AST so targets can read their annotations
+                    ...(allWorkflows[0]?.options?.deploy && { deploy: allWorkflows[0].options.deploy }),
+                },
             });
             // 6. Write files if not preview
             if (!preview) {

package/dist/parser.js

@@ -612,6 +612,7 @@ export class AnnotationParser {
                         label: portDef.label,
                         expression: portDef.expression,
                         ...(portDef.scope && { scope: portDef.scope }),
+                        ...(portDef.hidden && { hidden: portDef.hidden }),
                         ...(portDef.metadata && { metadata: portDef.metadata }),
                         ...(portDef.tsType && { tsType: portDef.tsType }),
                     };
@@ -624,6 +625,7 @@ export class AnnotationParser {
                         dataType: portDef.type,
                         label: portDef.label,
                         ...(portDef.scope && { scope: portDef.scope }),
+                        ...(portDef.hidden && { hidden: portDef.hidden }),
                         ...(portDef.metadata && { metadata: portDef.metadata }),
                         ...(portDef.tsType && { tsType: portDef.tsType }),
                     };
@@ -745,6 +747,7 @@ export class AnnotationParser {
                         tags: config.tags,
                     }
                     : undefined,
+                ...(config.deploy && { deploy: config.deploy }),
                 sourceLocation: {
                     file: sourceFile.getFilePath(),
                     line: fn.getStartLineNumber(false),
@@ -896,6 +899,8 @@ export class AnnotationParser {
                     ...(inst.sourceLocation && {
                         sourceLocation: { file: filePath, ...inst.sourceLocation },
                     }),
+                    ...(inst.job && { job: inst.job }),
+                    ...(inst.environment && { environment: inst.environment }),
                 };
             });
             // Convert connections to ConnectionAST
@@ -985,7 +990,11 @@ export class AnnotationParser {
                 ...(Object.keys(ui).length > 0 && { ui }),
                 ...((config.strictTypes !== undefined || config.autoConnect ||
                     config.trigger || config.cancelOn || config.retries !== undefined ||
-                    config.timeout || config.throttle) && {
+                    config.timeout || config.throttle ||
+                    config.secrets || config.runner || config.caches || config.artifacts ||
+                    config.environments || config.matrix || config.services ||
+                    config.concurrency || config.cicdTriggers ||
+                    config.deploy) && {
                     options: {
                         ...(config.strictTypes !== undefined && { strictTypes: config.strictTypes }),
                         ...(config.autoConnect && { autoConnect: true }),
@@ -994,6 +1003,24 @@ export class AnnotationParser {
                         ...(config.retries !== undefined && { retries: config.retries }),
                         ...(config.timeout && { timeout: config.timeout }),
                         ...(config.throttle && { throttle: config.throttle }),
+                        // CI/CD domain options (grouped)
+                        ...((config.secrets || config.runner || config.caches || config.artifacts ||
+                            config.environments || config.matrix || config.services ||
+                            config.concurrency || config.cicdTriggers) && {
+                            cicd: {
+                                ...(config.secrets && { secrets: config.secrets }),
+                                ...(config.runner && { runner: config.runner }),
+                                ...(config.caches && { caches: config.caches }),
+                                ...(config.artifacts && { artifacts: config.artifacts }),
+                                ...(config.environments && { environments: config.environments }),
+                                ...(config.matrix && { matrix: config.matrix }),
+                                ...(config.services && { services: config.services }),
+                                ...(config.concurrency && { concurrency: config.concurrency }),
+                                ...(config.cicdTriggers && { triggers: config.cicdTriggers }),
+                            },
+                        }),
+                        // Per-target deployment config
+                        ...(config.deploy && { deploy: config.deploy }),
                     },
                 }),
             });

package/dist/validation/cicd-detection.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CI/CD Workflow Detection
+ *
+ * Determines whether a workflow is a CI/CD pipeline based on annotations.
+ * A workflow is CI/CD if it has any CI/CD-specific annotations:
+ * @secret, @runner, @cache, @artifact, @environment, @matrix, @service,
+ * @concurrency, [job: "..."], or CI/CD trigger types (push, pull_request, etc.)
+ */
+import type { TWorkflowAST } from '../ast/types.js';
+/**
+ * Check if a workflow is a CI/CD pipeline.
+ *
+ * Detection signals (any one is sufficient):
+ * 1. Workflow options contain CI/CD fields (secrets, runner, caches, etc.)
+ * 2. Any node instance has a `job` attribute
+ * 3. Workflow has cicdTriggers
+ */
+export declare function isCICDWorkflow(ast: TWorkflowAST): boolean;
+/**
+ * Get all unique job names from a CI/CD workflow.
+ * Returns empty array if no jobs are defined.
+ */
+export declare function getJobNames(ast: TWorkflowAST): string[];
+/**
+ * Get all declared secret names from a CI/CD workflow.
+ */
+export declare function getDeclaredSecrets(ast: TWorkflowAST): string[];
+/**
+ * Get all secret:NAME references from connections.
+ * Returns array of secret names that are wired via @connect.
+ */
+export declare function getReferencedSecrets(ast: TWorkflowAST): string[];
+//# sourceMappingURL=cicd-detection.d.ts.map

package/dist/validation/cicd-detection.js

@@ -0,0 +1,76 @@
+/**
+ * CI/CD Workflow Detection
+ *
+ * Determines whether a workflow is a CI/CD pipeline based on annotations.
+ * A workflow is CI/CD if it has any CI/CD-specific annotations:
+ * @secret, @runner, @cache, @artifact, @environment, @matrix, @service,
+ * @concurrency, [job: "..."], or CI/CD trigger types (push, pull_request, etc.)
+ */
+/**
+ * Check if a workflow is a CI/CD pipeline.
+ *
+ * Detection signals (any one is sufficient):
+ * 1. Workflow options contain CI/CD fields (secrets, runner, caches, etc.)
+ * 2. Any node instance has a `job` attribute
+ * 3. Workflow has cicdTriggers
+ */
+export function isCICDWorkflow(ast) {
+    // Check CI/CD domain annotations
+    const cicd = ast.options?.cicd;
+    if (cicd) {
+        if (cicd.secrets && cicd.secrets.length > 0)
+            return true;
+        if (cicd.runner)
+            return true;
+        if (cicd.caches && cicd.caches.length > 0)
+            return true;
+        if (cicd.artifacts && cicd.artifacts.length > 0)
+            return true;
+        if (cicd.environments && cicd.environments.length > 0)
+            return true;
+        if (cicd.matrix)
+            return true;
+        if (cicd.services && cicd.services.length > 0)
+            return true;
+        if (cicd.concurrency)
+            return true;
+        if (cicd.triggers && cicd.triggers.length > 0)
+            return true;
+    }
+    // Check node-level CI/CD annotations
+    if (ast.instances.some((inst) => inst.job))
+        return true;
+    return false;
+}
+/**
+ * Get all unique job names from a CI/CD workflow.
+ * Returns empty array if no jobs are defined.
+ */
+export function getJobNames(ast) {
+    const jobs = new Set();
+    for (const inst of ast.instances) {
+        if (inst.job)
+            jobs.add(inst.job);
+    }
+    return Array.from(jobs);
+}
+/**
+ * Get all declared secret names from a CI/CD workflow.
+ */
+export function getDeclaredSecrets(ast) {
+    return (ast.options?.cicd?.secrets || []).map((s) => s.name);
+}
+/**
+ * Get all secret:NAME references from connections.
+ * Returns array of secret names that are wired via @connect.
+ */
+export function getReferencedSecrets(ast) {
+    const secrets = new Set();
+    for (const conn of ast.connections) {
+        if (conn.from.node.startsWith('secret:')) {
+            secrets.add(conn.from.node.substring(7)); // strip "secret:" prefix
+        }
+    }
+    return Array.from(secrets);
+}
+//# sourceMappingURL=cicd-detection.js.map

package/dist/validation/cicd-rules.d.ts

@@ -0,0 +1,62 @@
+/**
+ * CI/CD-Specific Validation Rules
+ *
+ * Custom TValidationRule implementations for CI/CD pipeline workflows.
+ * These run AFTER the built-in validator via the api/validate.ts custom rules injection.
+ *
+ * Rules:
+ * 1. CICD_SECRET_NOT_DECLARED - secret:X referenced but no @secret X declared
+ * 2. CICD_SECRET_UNUSED - @secret X declared but never wired
+ * 3. CICD_TRIGGER_MISSING - No trigger annotations — pipeline would never run
+ * 4. CICD_JOB_MISSING_RUNNER - Job has no runner (uses workflow default or none)
+ * 5. CICD_ARTIFACT_CROSS_JOB - Data flows between jobs without @artifact declaration
+ * 6. CICD_CIRCULAR_JOB_DEPS - Job dependency cycle detected
+ * 7. CICD_MATRIX_WITH_ENVIRONMENT - Matrix + environment = N approval prompts
+ */
+import type { TValidationRule } from '../ast/types.js';
+/**
+ * A `secret:X` pseudo-node is referenced in @connect but no `@secret X` is declared.
+ * This means the export target won't know about the secret and can't generate
+ * proper environment variable references.
+ */
+export declare const secretNotDeclaredRule: TValidationRule;
+/**
+ * A `@secret X` is declared but never wired via `@connect secret:X -> ...`.
+ * The secret might be intentional (used in a shell-command step) or a leftover.
+ */
+export declare const secretUnusedRule: TValidationRule;
+/**
+ * A CI/CD workflow with no trigger annotations would never run automatically.
+ * Needs at least one @trigger (push, pull_request, schedule, dispatch, or tag).
+ */
+export declare const triggerMissingRule: TValidationRule;
+/**
+ * A job (group of nodes with same [job: "name"]) has no explicit runner
+ * and the workflow has no default @runner. The export target will use a
+ * platform default, which may not be what the user expects.
+ */
+export declare const jobMissingRunnerRule: TValidationRule;
+/**
+ * Data flows between nodes in different jobs via connections, but no @artifact
+ * is declared. In CI/CD, each job runs in a fresh environment — data must be
+ * explicitly passed via artifacts.
+ */
+export declare const artifactCrossJobRule: TValidationRule;
+/**
+ * Job dependencies (derived from @path connections between jobs) form a cycle.
+ * CI/CD platforms reject circular job dependencies.
+ */
+export declare const circularJobDepsRule: TValidationRule;
+/**
+ * Using @matrix with @environment protection means each matrix combination
+ * triggers an approval prompt. For a 3x2 matrix, that's 6 prompts.
+ */
+export declare const matrixWithEnvironmentRule: TValidationRule;
+/** All CI/CD validation rules */
+export declare const cicdValidationRules: TValidationRule[];
+/**
+ * Get all CI/CD validation rules.
+ * Convenience function for passing to validateWorkflow().
+ */
+export declare function getCICDValidationRules(): TValidationRule[];
+//# sourceMappingURL=cicd-rules.d.ts.map