@synergenius/flow-weaver 0.13.2 → 0.14.0

package/dist/deployment/targets/gitlab-ci.js

@@ -0,0 +1,374 @@
+/**
+ * GitLab CI Export Target
+ *
+ * Generates .gitlab-ci.yml from a Flow Weaver CI/CD workflow.
+ * No FW runtime dependency — outputs native GitLab CI YAML.
+ *
+ * Key differences from GitHub Actions:
+ * - `stage:` instead of job `needs:` (generates `stages:` list)
+ * - `$CI_VARIABLE` instead of `${{ secrets.NAME }}`
+ * - `cache:` and `artifacts:` as native YAML keywords (no separate actions)
+ * - `services:` as native keyword
+ * - `rules:` for conditional execution
+ * - `environment:` as native keyword with `url:` and `when: manual` for approval
+ */
+import { stringify as yamlStringify } from 'yaml';
+import { isCICDWorkflow } from '../../validation/cicd-detection.js';
+import { BaseCICDTarget, } from './cicd-base.js';
+import { parseWorkflow } from '../../api/index.js';
+import * as path from 'path';
+export class GitLabCITarget extends BaseCICDTarget {
+    name = 'gitlab-ci';
+    description = 'GitLab CI/CD pipeline (.gitlab-ci.yml)';
+    deploySchema = {
+        runner: { type: 'string', description: 'Default Docker image', default: 'ubuntu:latest' },
+    };
+    nodeTypeDeploySchema = {
+        script: { type: 'string[]', description: 'GitLab CI script commands' },
+        image: { type: 'string', description: 'Docker image override' },
+        label: { type: 'string', description: 'Step display name' },
+    };
+    async generate(options) {
+        const filePath = path.resolve(options.sourceFile);
+        const outputDir = path.resolve(options.outputDir);
+        // Parse the workflow file to get AST
+        const parseResult = await parseWorkflow(filePath, { nodeTypesOnly: false });
+        if (parseResult.errors.length > 0) {
+            throw new Error(`Parse errors: ${parseResult.errors.join('; ')}`);
+        }
+        const allWorkflows = parseResult.allWorkflows || [];
+        const targetWorkflows = options.workflowName
+            ? allWorkflows.filter((w) => w.name === options.workflowName || w.functionName === options.workflowName)
+            : allWorkflows.filter((w) => isCICDWorkflow(w));
+        if (targetWorkflows.length === 0) {
+            throw new Error('No CI/CD workflows found. Ensure workflow has CI/CD annotations (@secret, @runner, @trigger, [job:], etc.)');
+        }
+        const files = [];
+        for (const ast of targetWorkflows) {
+            // Build job graph
+            const jobs = this.buildJobGraph(ast);
+            // Resolve secrets
+            this.resolveJobSecrets(jobs, ast, (name) => `$${name}`);
+            // Inject artifacts
+            const artifacts = ast.options?.cicd?.artifacts || [];
+            this.injectArtifactSteps(jobs, artifacts);
+            // Apply workflow options
+            this.applyWorkflowOptions(jobs, ast);
+            // Generate YAML
+            const yamlContent = this.renderPipelineYAML(ast, jobs);
+            files.push(this.createFile(outputDir, '.gitlab-ci.yml', yamlContent, 'config'));
+            // Generate secrets doc if secrets exist
+            const secrets = ast.options?.cicd?.secrets || [];
+            if (secrets.length > 0) {
+                const secretsDoc = this.generateSecretsDoc(secrets, 'gitlab-ci');
+                files.push(this.createFile(outputDir, 'SECRETS_SETUP.md', secretsDoc, 'other'));
+            }
+        }
+        return {
+            files,
+            target: this.name,
+            workflowName: options.displayName || targetWorkflows[0].name,
+            entryPoint: files[0].relativePath,
+        };
+    }
+    getDeployInstructions(_artifacts) {
+        return {
+            title: 'Deploy GitLab CI Pipeline',
+            prerequisites: [
+                'GitLab repository',
+                'CI/CD variables configured (see SECRETS_SETUP.md)',
+                'GitLab Runner available (shared or project-specific)',
+            ],
+            steps: [
+                'Copy .gitlab-ci.yml to your repository root',
+                'Configure required variables in GitLab (Settings > CI/CD > Variables)',
+                'Push to trigger the pipeline',
+            ],
+            localTestSteps: [
+                'Install gitlab-runner: brew install gitlab-runner',
+                'Run locally: gitlab-runner exec docker <job-name>',
+            ],
+            links: [
+                { label: 'GitLab CI/CD Docs', url: 'https://docs.gitlab.com/ee/ci/' },
+                { label: 'GitLab CI Lint', url: 'https://docs.gitlab.com/ee/ci/lint.html' },
+            ],
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Private: YAML Rendering
+    // ---------------------------------------------------------------------------
+    renderPipelineYAML(ast, jobs) {
+        const doc = {};
+        // stages (derived from job dependency order)
+        const stages = this.deriveStages(jobs);
+        doc.stages = stages;
+        // Default image
+        const defaultImage = this.deriveDefaultImage(ast, jobs);
+        if (defaultImage) {
+            doc.default = { image: defaultImage };
+        }
+        // Workflow-level rules (from triggers)
+        const rules = this.renderWorkflowRules(ast.options?.cicd?.triggers || []);
+        if (rules.length > 0) {
+            doc.workflow = { rules };
+        }
+        // Job definitions
+        for (const job of jobs) {
+            doc[job.id] = this.renderJob(job, ast, stages);
+        }
+        return yamlStringify(doc, {
+            lineWidth: 120,
+            defaultStringType: 'PLAIN',
+            defaultKeyType: 'PLAIN',
+        });
+    }
+    /**
+     * Derive stages from job dependency order.
+     * Jobs with no deps → stage 1, jobs depending on stage 1 → stage 2, etc.
+     */
+    deriveStages(jobs) {
+        const stages = [];
+        const assigned = new Map();
+        // Assign stages based on dependency depth
+        function getStage(jobId, jobs) {
+            if (assigned.has(jobId))
+                return assigned.get(jobId);
+            const job = jobs.find((j) => j.id === jobId);
+            if (!job || job.needs.length === 0) {
+                assigned.set(jobId, jobId);
+                return jobId;
+            }
+            // Stage is one after the latest dependency
+            const depStages = job.needs.map((dep) => getStage(dep, jobs));
+            assigned.set(jobId, jobId);
+            return jobId;
+        }
+        // Simple: use job IDs as stage names, ordered by dependency
+        for (const job of jobs) {
+            getStage(job.id, jobs);
+            if (!stages.includes(job.id)) {
+                stages.push(job.id);
+            }
+        }
+        return stages;
+    }
+    /**
+     * Derive default image from @deploy annotations or built-in mappings.
+     */
+    deriveDefaultImage(_ast, jobs) {
+        // Check steps for @deploy gitlab-ci image or built-in mapping
+        for (const job of jobs) {
+            for (const step of job.steps) {
+                const mapping = this.resolveActionMapping(step, 'gitlab-ci');
+                if (mapping?.gitlabImage)
+                    return mapping.gitlabImage;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Convert CI/CD triggers to GitLab CI workflow rules.
+     */
+    renderWorkflowRules(triggers) {
+        if (triggers.length === 0)
+            return [];
+        const rules = [];
+        for (const trigger of triggers) {
+            switch (trigger.type) {
+                case 'push':
+                    if (trigger.branches) {
+                        for (const branch of trigger.branches) {
+                            rules.push({
+                                if: `$CI_COMMIT_BRANCH == "${branch}"`,
+                                when: 'always',
+                            });
+                        }
+                    }
+                    else {
+                        rules.push({ if: '$CI_PIPELINE_SOURCE == "push"', when: 'always' });
+                    }
+                    break;
+                case 'pull_request':
+                    rules.push({
+                        if: '$CI_PIPELINE_SOURCE == "merge_request_event"',
+                        when: 'always',
+                    });
+                    break;
+                case 'schedule':
+                    rules.push({
+                        if: '$CI_PIPELINE_SOURCE == "schedule"',
+                        when: 'always',
+                    });
+                    break;
+                case 'dispatch':
+                    rules.push({
+                        if: '$CI_PIPELINE_SOURCE == "web" || $CI_PIPELINE_SOURCE == "api"',
+                        when: 'always',
+                    });
+                    break;
+                case 'tag':
+                    rules.push({ if: '$CI_COMMIT_TAG', when: 'always' });
+                    break;
+            }
+        }
+        return rules;
+    }
+    renderJob(job, ast, stages) {
+        const jobObj = {};
+        // stage
+        jobObj.stage = job.id;
+        // image (from runner or default)
+        if (job.runner && job.runner !== 'ubuntu-latest') {
+            // GitLab uses Docker images, not runner labels
+            // Map common GitHub runners to Docker images
+            const imageMap = {
+                'ubuntu-latest': 'ubuntu:latest',
+                'ubuntu-22.04': 'ubuntu:22.04',
+                'ubuntu-20.04': 'ubuntu:20.04',
+            };
+            const image = imageMap[job.runner] || job.runner;
+            jobObj.image = image;
+        }
+        // needs (for DAG mode instead of stage-based ordering)
+        if (job.needs.length > 0) {
+            jobObj.needs = job.needs;
+        }
+        // environment
+        if (job.environment) {
+            const envConfig = ast.options?.cicd?.environments?.find((e) => e.name === job.environment);
+            const envObj = { name: job.environment };
+            if (envConfig?.url)
+                envObj.url = envConfig.url;
+            if (envConfig?.reviewers)
+                envObj.deployment_tier = 'production';
+            jobObj.environment = envObj;
+            // Protected environments require manual approval in GitLab
+            if (envConfig?.reviewers) {
+                jobObj.when = 'manual';
+            }
+        }
+        // services
+        if (job.services && job.services.length > 0) {
+            jobObj.services = job.services.map((svc) => {
+                const svcObj = { name: svc.image };
+                if (svc.ports) {
+                    // GitLab services expose the first port automatically
+                    // Additional port mapping needs alias
+                }
+                return svcObj;
+            });
+        }
+        // variables (from secrets)
+        if (job.secrets.length > 0) {
+            // In GitLab, CI/CD variables are automatically available
+            // But we document them for clarity
+            const variables = {};
+            for (const secret of job.secrets) {
+                variables[secret] = `$${secret}`;
+            }
+            jobObj.variables = variables;
+        }
+        // cache
+        if (job.cache) {
+            jobObj.cache = this.renderCache(job.cache);
+        }
+        // artifacts (upload)
+        if (job.uploadArtifacts && job.uploadArtifacts.length > 0) {
+            const paths = job.uploadArtifacts.map((a) => a.path);
+            const expiry = job.uploadArtifacts[0].retention
+                ? `${job.uploadArtifacts[0].retention} days`
+                : '1 week';
+            jobObj.artifacts = {
+                paths,
+                expire_in: expiry,
+            };
+        }
+        // script (the actual steps)
+        const script = [];
+        // Download artifacts (GitLab handles this automatically via `needs:`)
+        // but we add a comment for clarity if explicit artifacts are expected
+        if (job.downloadArtifacts && job.downloadArtifacts.length > 0) {
+            script.push(`# Artifacts from: ${job.downloadArtifacts.join(', ')} (downloaded automatically via needs:)`);
+        }
+        // Step scripts
+        for (const step of job.steps) {
+            const stepScript = this.renderStepScript(step);
+            script.push(...stepScript);
+        }
+        jobObj.script = script;
+        return jobObj;
+    }
+    renderStepScript(step) {
+        const mapping = this.resolveActionMapping(step, 'gitlab-ci');
+        const lines = [];
+        // Add env vars as export statements if present
+        if (step.env) {
+            for (const [key, value] of Object.entries(step.env)) {
+                lines.push(`export ${key}="${value}"`);
+            }
+        }
+        if (mapping?.gitlabScript) {
+            lines.push(`# ${mapping.label || step.name}`);
+            lines.push(...mapping.gitlabScript);
+        }
+        else {
+            // Unknown node type — generate TODO
+            lines.push(`# TODO: Implement '${step.id}' (node type: ${step.nodeType})`);
+            lines.push(`echo "Step: ${step.name}"`);
+        }
+        return lines;
+    }
+    renderCache(cache) {
+        const cacheObj = {};
+        switch (cache.strategy) {
+            case 'npm':
+                cacheObj.key = {
+                    files: [cache.key || 'package-lock.json'],
+                };
+                cacheObj.paths = [cache.path || 'node_modules/'];
+                break;
+            case 'pip':
+                cacheObj.key = {
+                    files: [cache.key || 'requirements.txt'],
+                };
+                cacheObj.paths = [cache.path || '.pip-cache/'];
+                break;
+            default:
+                cacheObj.key = cache.key || '$CI_COMMIT_REF_SLUG';
+                cacheObj.paths = [cache.path || '.cache/'];
+        }
+        return cacheObj;
+    }
+    /**
+     * Apply workflow-level options to jobs.
+     */
+    applyWorkflowOptions(jobs, ast) {
+        const cicd = ast.options?.cicd;
+        if (!cicd)
+            return;
+        // Apply cache to all jobs
+        if (cicd.caches && cicd.caches.length > 0) {
+            for (const job of jobs) {
+                if (!job.cache) {
+                    job.cache = cicd.caches[0];
+                }
+            }
+        }
+        // Apply services to all jobs
+        if (cicd.services && cicd.services.length > 0) {
+            for (const job of jobs) {
+                if (!job.services) {
+                    job.services = cicd.services;
+                }
+            }
+        }
+        // Apply matrix (GitLab uses `parallel: matrix:`)
+        if (cicd.matrix) {
+            const rootJobs = jobs.filter((j) => j.needs.length === 0);
+            for (const job of rootJobs) {
+                job.matrix = cicd.matrix;
+            }
+        }
+    }
+}
+//# sourceMappingURL=gitlab-ci.js.map

package/dist/deployment/targets/inngest.d.ts

@@ -12,6 +12,31 @@ import { BaseExportTarget, type ExportOptions, type ExportArtifacts, type Deploy
 export declare class InngestTarget extends BaseExportTarget {
     readonly name = "inngest";
     readonly description = "Inngest \u2014 durable, event-driven workflow functions";
+    readonly deploySchema: {
+        durableSteps: {
+            type: "boolean";
+            description: string;
+            default: boolean;
+        };
+        framework: {
+            type: "string";
+            description: string;
+        };
+        serve: {
+            type: "boolean";
+            description: string;
+            default: boolean;
+        };
+        retries: {
+            type: "number";
+            description: string;
+            default: number;
+        };
+        triggerEvent: {
+            type: "string";
+            description: string;
+        };
+    };
     /**
      * Sanitize a name into a valid Inngest ID (lowercase, alphanumeric + hyphens)
      */

package/dist/deployment/targets/inngest.js

@@ -394,6 +394,13 @@ export default app;
 export class InngestTarget extends BaseExportTarget {
     name = 'inngest';
     description = 'Inngest — durable, event-driven workflow functions';
+    deploySchema = {
+        durableSteps: { type: 'boolean', description: 'Per-node step.run() for durability', default: false },
+        framework: { type: 'string', description: 'Framework adapter: next, express, hono, fastify, remix' },
+        serve: { type: 'boolean', description: 'Generate serve() handler export', default: false },
+        retries: { type: 'number', description: 'Retries per function', default: 3 },
+        triggerEvent: { type: 'string', description: 'Custom trigger event name' },
+    };
     /**
      * Sanitize a name into a valid Inngest ID (lowercase, alphanumeric + hyphens)
      */
@@ -413,7 +420,9 @@ export class InngestTarget extends BaseExportTarget {
     async generate(options) {
         const files = [];
         const includeDocs = options.includeDocs ?? false;
-        const durableSteps = options.targetOptions?.durableSteps === true;
+        // @deploy inngest annotations take precedence over CLI flags
+        const deployConfig = options.targetOptions?.deploy?.inngest;
+        const durableSteps = deployConfig?.durableSteps === true || options.targetOptions?.durableSteps === true;
         const serviceId = this.toInngestId(options.displayName);
         const functionId = this.toInngestId(options.workflowName);
         const functionVar = `fn_${this.toVarName(options.workflowName)}`;

package/dist/deployment/targets/lambda.d.ts

@@ -10,6 +10,23 @@ import { BaseExportTarget, type ExportOptions, type ExportArtifacts, type Deploy
 export declare class LambdaTarget extends BaseExportTarget {
     readonly name = "lambda";
     readonly description = "AWS Lambda with SAM (Serverless Application Model)";
+    readonly deploySchema: {
+        memory: {
+            type: "number";
+            description: string;
+            default: number;
+        };
+        runtime: {
+            type: "string";
+            description: string;
+            default: string;
+        };
+        timeout: {
+            type: "number";
+            description: string;
+            default: number;
+        };
+    };
     generate(options: ExportOptions): Promise<ExportArtifacts>;
     /**
      * Generate OpenAPI specification for the workflow

package/dist/deployment/targets/lambda.js

@@ -873,6 +873,11 @@ Outputs:
 export class LambdaTarget extends BaseExportTarget {
     name = 'lambda';
     description = 'AWS Lambda with SAM (Serverless Application Model)';
+    deploySchema = {
+        memory: { type: 'number', description: 'Lambda memory in MB', default: 256 },
+        runtime: { type: 'string', description: 'Lambda runtime', default: 'nodejs20.x' },
+        timeout: { type: 'number', description: 'Function timeout in seconds', default: 30 },
+    };
     async generate(options) {
         const files = [];
         const includeDocs = options.includeDocs ?? false;

package/dist/deployment/targets/vercel.d.ts

@@ -10,6 +10,22 @@ import { BaseExportTarget, type ExportOptions, type ExportArtifacts, type Deploy
 export declare class VercelTarget extends BaseExportTarget {
     readonly name = "vercel";
     readonly description = "Vercel Serverless Functions";
+    readonly deploySchema: {
+        maxDuration: {
+            type: "number";
+            description: string;
+            default: number;
+        };
+        memory: {
+            type: "number";
+            description: string;
+            default: number;
+        };
+        regions: {
+            type: "string[]";
+            description: string;
+        };
+    };
     generate(options: ExportOptions): Promise<ExportArtifacts>;
     /**
      * Generate OpenAPI specification for the workflow

package/dist/deployment/targets/vercel.js

@@ -519,6 +519,11 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
 export class VercelTarget extends BaseExportTarget {
     name = 'vercel';
     description = 'Vercel Serverless Functions';
+    deploySchema = {
+        maxDuration: { type: 'number', description: 'Max function duration in seconds', default: 60 },
+        memory: { type: 'number', description: 'Memory in MB', default: 1024 },
+        regions: { type: 'string[]', description: 'Deployment regions' },
+    };
     async generate(options) {
         const files = [];
         const maxDuration = options.targetOptions?.maxDuration || 60;

package/dist/diagram/geometry.js

@@ -176,19 +176,19 @@ function orderedPorts(ports, direction) {
 function buildInstanceNode(instId, instNodeType, instConfig, nodeTypeMap, theme = 'dark') {
     const nt = nodeTypeMap.get(instNodeType);
     const allInputs = nt
-        ? { ...filterNonScopedPorts(nt.inputs) }
+        ? filterHiddenPorts(filterNonScopedPorts(nt.inputs))
         : {};
     const allOutputs = nt
-        ? { ...filterNonScopedPorts(nt.outputs) }
+        ? filterHiddenPorts(filterNonScopedPorts(nt.outputs))
         : {};
     if (nt && !nt.expression) {
-        if (!allInputs.execute)
+        if (!allInputs.execute && !nt.inputs.execute?.hidden)
             allInputs.execute = { dataType: 'STEP' };
     }
-    if (nt && nt.hasSuccessPort && !allOutputs.onSuccess) {
+    if (nt && nt.hasSuccessPort && !allOutputs.onSuccess && !nt.outputs.onSuccess?.hidden) {
         allOutputs.onSuccess = { dataType: 'STEP', isControlFlow: true };
     }
-    if (nt && nt.hasFailurePort && !allOutputs.onFailure) {
+    if (nt && nt.hasFailurePort && !allOutputs.onFailure && !nt.outputs.onFailure?.hidden) {
         allOutputs.onFailure = { dataType: 'STEP', isControlFlow: true, failure: true };
     }
     // Resolve icon: instance config → node type visuals → auto-detection
@@ -1084,6 +1084,14 @@ function findScopeParent(childId, diagramNodes) {
     }
     return undefined;
 }
+function filterHiddenPorts(ports) {
+    const result = {};
+    for (const [name, def] of Object.entries(ports)) {
+        if (!def.hidden)
+            result[name] = def;
+    }
+    return result;
+}
 function filterNonScopedPorts(ports) {
     const result = {};
     for (const [name, def] of Object.entries(ports)) {

package/dist/export/index.d.ts

@@ -3,9 +3,13 @@
  * Generates deployment-ready handlers for various platforms
  */
 /**
- * Supported export targets
+ * Export target identifier.
+ *
+ * Widened to `string` so marketplace packs can register arbitrary targets
+ * without modifying core. Well-known built-in names (when packs are installed):
+ * 'lambda', 'vercel', 'cloudflare', 'inngest', 'github-actions', 'gitlab-ci'
  */
-export type ExportTarget = 'lambda' | 'vercel' | 'cloudflare' | 'inngest';
+export type ExportTarget = string;
 /**
  * Options for exporting a workflow
  */
@@ -54,15 +58,15 @@ export interface ExportResult {
     openApiSpec?: object;
 }
 /**
- * Export multiple workflows as a single service
- */
-export declare function exportMultiWorkflow(options: ExportOptions): Promise<ExportResult>;
-/**
- * Export a workflow for serverless deployment
+ * Export a workflow for deployment.
+ *
+ * Delegates to the target registry — every target is a plugin discovered
+ * from installed marketplace packs. The legacy template system has been
+ * replaced by target classes that generate their own handler + config.
  */
 export declare function exportWorkflow(options: ExportOptions): Promise<ExportResult>;
 /**
- * List supported export targets
+ * List installed export targets by querying the registry.
  */
-export declare function getSupportedTargets(): ExportTarget[];
+export declare function getSupportedTargets(projectDir?: string): Promise<string[]>;
 //# sourceMappingURL=index.d.ts.map