@synergenius/flow-weaver 0.17.0 → 0.17.2

package/dist/{deployment/targets/cicd-base.d.ts → extensions/cicd/base-target.d.ts}

@@ -7,12 +7,12 @@
  *
  * Key responsibilities:
  * - Build job graph from AST (group nodes by @job, compute dependencies)
- * - Resolve secret wiring (secret: pseudo-node connections → job env vars)
+ * - Resolve secret wiring (secret: pseudo-node connections -> job env vars)
  * - Inject artifact upload/download steps between jobs
  * - Generate SECRETS_SETUP.md documentation
  */
 import type { TWorkflowAST, TCICDSecret, TCICDCache, TCICDArtifact, TCICDService, TCICDMatrix } from '../../ast/types.js';
-import { BaseExportTarget, type ExportOptions, type MultiWorkflowArtifacts, type CompiledWorkflow, type NodeTypeArtifacts, type NodeTypeInfo, type NodeTypeExportOptions, type BundleArtifacts, type BundleWorkflow, type BundleNodeType } from './base.js';
+import { BaseExportTarget, type ExportOptions, type MultiWorkflowArtifacts, type CompiledWorkflow, type NodeTypeArtifacts, type NodeTypeInfo, type NodeTypeExportOptions, type BundleArtifacts, type BundleWorkflow, type BundleNodeType } from '../../deployment/targets/base.js';
 export interface CICDStep {
     /** Node instance ID */
     id: string;
@@ -50,6 +50,37 @@ export interface CICDJob {
     uploadArtifacts?: TCICDArtifact[];
     /** Artifact names to download before this job */
     downloadArtifacts?: string[];
+    /** Maximum retry count on failure (from @job) */
+    retry?: number;
+    /** Whether this job can fail without failing the pipeline (from @job) */
+    allowFailure?: boolean;
+    /** Job-level timeout duration (from @job) */
+    timeout?: string;
+    /** Environment variables (from @job or @variables) */
+    variables?: Record<string, string>;
+    /** Runner selection tags (from @job or @tags) */
+    tags?: string[];
+    /** Setup commands before main script (from @job or @before_script) */
+    beforeScript?: string[];
+    /** Conditional execution rules (from @job) */
+    rules?: Array<{
+        if?: string;
+        when?: string;
+        allowFailure?: boolean;
+        variables?: Record<string, string>;
+        changes?: string[];
+    }>;
+    /** Coverage regex pattern (from @job) */
+    coverage?: string;
+    /** Test/coverage report declarations (from @job) */
+    reports?: Array<{
+        type: string;
+        path: string;
+    }>;
+    /** GitLab template to extend (from @job) */
+    extends?: string;
+    /** Explicit stage name (from @stage) */
+    stage?: string;
 }
 export interface ActionMapping {
     /** GitHub Actions `uses:` value */
@@ -63,49 +94,17 @@ export interface ActionMapping {
     /** Human-readable step name */
     label?: string;
 }
-/**
- * Default mapping from FW node types to CI/CD platform actions.
- * Unknown node types fall back to a TODO placeholder.
- */
 export declare const NODE_ACTION_MAP: Record<string, ActionMapping>;
 export declare abstract class BaseCICDTarget extends BaseExportTarget {
-    /**
-     * CI/CD targets don't compile workflows — they read the AST and generate YAML.
-     * The generate() method must be implemented by each platform target.
-     */
     generateMultiWorkflow(_workflows: CompiledWorkflow[], _options: ExportOptions): Promise<MultiWorkflowArtifacts>;
     generateNodeTypeService(_nodeTypes: NodeTypeInfo[], _options: NodeTypeExportOptions): Promise<NodeTypeArtifacts>;
     generateBundle(_workflows: BundleWorkflow[], _nodeTypes: BundleNodeType[], _options: ExportOptions): Promise<BundleArtifacts>;
-    /**
-     * Resolve the action mapping for a node type.
-     * Priority: @deploy annotations on the node type → NODE_ACTION_MAP fallback → undefined.
-     *
-     * This makes marketplace packages self-describing: a node type with
-     * `@deploy github-actions action="actions/checkout@v4"` contributes its own mapping.
-     */
     protected resolveActionMapping(step: CICDStep, targetName: string): ActionMapping | undefined;
-    /**
-     * Build the job graph from the workflow AST.
-     * Groups nodes by their [job: "name"] attribute and computes dependencies
-     * from connections between nodes in different jobs.
-     */
     protected buildJobGraph(ast: TWorkflowAST): CICDJob[];
-    /**
-     * Topologically sort jobs so that dependencies come first.
-     */
     private topoSortJobs;
-    /**
-     * Map secret:NAME connections to the jobs that need them.
-     * Populates job.secrets and step.env for each secret connection.
-     */
+    private computeJobDepths;
     protected resolveJobSecrets(jobs: CICDJob[], ast: TWorkflowAST, renderSecretRef: (name: string) => string): void;
-    /**
-     * Add artifact upload/download steps between jobs.
-     */
     protected injectArtifactSteps(jobs: CICDJob[], artifacts: TCICDArtifact[]): void;
-    /**
-     * Generate SECRETS_SETUP.md with per-secret setup instructions.
-     */
     protected generateSecretsDoc(secrets: TCICDSecret[], platform: string): string;
 }
-//# sourceMappingURL=cicd-base.d.ts.map
+//# sourceMappingURL=base-target.d.ts.map

package/dist/{deployment/targets/cicd-base.js → extensions/cicd/base-target.js}

@@ -7,15 +7,11 @@
  *
  * Key responsibilities:
  * - Build job graph from AST (group nodes by @job, compute dependencies)
- * - Resolve secret wiring (secret: pseudo-node connections → job env vars)
+ * - Resolve secret wiring (secret: pseudo-node connections -> job env vars)
  * - Inject artifact upload/download steps between jobs
  * - Generate SECRETS_SETUP.md documentation
  */
-import { BaseExportTarget, } from './base.js';
-/**
- * Default mapping from FW node types to CI/CD platform actions.
- * Unknown node types fall back to a TODO placeholder.
- */
+import { BaseExportTarget, } from '../../deployment/targets/base.js';
 export const NODE_ACTION_MAP = {
     checkout: {
         githubAction: 'actions/checkout@v4',
@@ -83,7 +79,7 @@ export const NODE_ACTION_MAP = {
     },
     'slack-notify': {
         githubAction: 'slackapi/slack-github-action@v1',
-        gitlabScript: ['curl -X POST -H "Content-type: application/json" --data "{\"text\":\"Pipeline complete\"}" $SLACK_WEBHOOK_URL'],
+        gitlabScript: ['curl -X POST -H "Content-type: application/json" --data "{\\\"text\\\":\\\"Pipeline complete\\\"}" $SLACK_WEBHOOK_URL'],
         label: 'Send Slack notification',
     },
     'health-check': {
@@ -101,11 +97,6 @@ export const NODE_ACTION_MAP = {
 // Base CI/CD Target
 // ---------------------------------------------------------------------------
 export class BaseCICDTarget extends BaseExportTarget {
-    /**
-     * CI/CD targets don't compile workflows — they read the AST and generate YAML.
-     * The generate() method must be implemented by each platform target.
-     */
-    // Not used by CI/CD targets (they don't produce serverless handlers)
     async generateMultiWorkflow(_workflows, _options) {
         throw new Error('CI/CD targets use generate() with AST, not generateMultiWorkflow()');
     }
@@ -118,15 +109,7 @@ export class BaseCICDTarget extends BaseExportTarget {
     // ---------------------------------------------------------------------------
     // Shared CI/CD Logic
     // ---------------------------------------------------------------------------
-    /**
-     * Resolve the action mapping for a node type.
-     * Priority: @deploy annotations on the node type → NODE_ACTION_MAP fallback → undefined.
-     *
-     * This makes marketplace packages self-describing: a node type with
-     * `@deploy github-actions action="actions/checkout@v4"` contributes its own mapping.
-     */
     resolveActionMapping(step, targetName) {
-        // 1. Check @deploy annotations on the node type
         const deployConfig = step.nodeTypeDeploy?.[targetName];
         if (deployConfig) {
             return {
@@ -145,23 +128,16 @@ export class BaseCICDTarget extends BaseExportTarget {
                 label: deployConfig.label || step.name,
             };
         }
-        // 2. Fall back to built-in NODE_ACTION_MAP
-        return NODE_ACTION_MAP[step.nodeType];
+        return NODE_ACTION_MAP[step.nodeType]
+            || NODE_ACTION_MAP[step.nodeType.replace(/([A-Z])/g, '-$1').toLowerCase()];
     }
-    /**
-     * Build the job graph from the workflow AST.
-     * Groups nodes by their [job: "name"] attribute and computes dependencies
-     * from connections between nodes in different jobs.
-     */
     buildJobGraph(ast) {
-        // Build node type lookup for @deploy annotations
         const nodeTypeLookup = new Map();
         for (const nt of ast.nodeTypes) {
             nodeTypeLookup.set(nt.name, nt);
             if (nt.functionName !== nt.name)
                 nodeTypeLookup.set(nt.functionName, nt);
         }
-        // Group instances by job
         const jobMap = new Map();
         const defaultRunner = ast.options?.cicd?.runner;
         for (const inst of ast.instances) {
@@ -170,12 +146,10 @@ export class BaseCICDTarget extends BaseExportTarget {
                 jobMap.set(jobName, []);
             jobMap.get(jobName).push(inst);
         }
-        // Build node -> job lookup
         const nodeJob = new Map();
         for (const inst of ast.instances) {
             nodeJob.set(inst.id, inst.job || 'default');
         }
-        // Build job dependency graph from connections
         const jobDeps = new Map();
         for (const conn of ast.connections) {
             if (conn.from.node.startsWith('secret:'))
@@ -190,10 +164,8 @@ export class BaseCICDTarget extends BaseExportTarget {
                 jobDeps.get(toJob).add(fromJob);
             }
         }
-        // Convert to CICDJob array
         const jobs = [];
         for (const [jobId, instances] of jobMap) {
-            // Determine environment from first instance with one
             const environment = instances.find((i) => i.environment)?.environment;
             const steps = instances.map((inst) => {
                 const nt = nodeTypeLookup.get(inst.nodeType);
@@ -217,12 +189,76 @@ export class BaseCICDTarget extends BaseExportTarget {
                 secrets: [],
             });
         }
-        // Topologically sort jobs so dependencies come first
+        // Apply @job configs
+        const jobConfigs = ast.options?.cicd?.jobs;
+        if (jobConfigs) {
+            for (const jc of jobConfigs) {
+                const job = jobs.find(j => j.id === jc.id);
+                if (!job)
+                    continue;
+                if (jc.retry !== undefined)
+                    job.retry = jc.retry;
+                if (jc.allowFailure !== undefined)
+                    job.allowFailure = jc.allowFailure;
+                if (jc.timeout)
+                    job.timeout = jc.timeout;
+                if (jc.variables)
+                    job.variables = { ...job.variables, ...jc.variables };
+                if (jc.tags)
+                    job.tags = jc.tags;
+                if (jc.beforeScript)
+                    job.beforeScript = jc.beforeScript;
+                if (jc.rules)
+                    job.rules = jc.rules;
+                if (jc.coverage)
+                    job.coverage = jc.coverage;
+                if (jc.reports)
+                    job.reports = jc.reports;
+                if (jc.runner)
+                    job.runner = jc.runner;
+                if (jc.extends)
+                    job.extends = jc.extends;
+            }
+        }
+        // Apply @stage assignments
+        const stages = ast.options?.cicd?.stages;
+        if (stages && stages.length > 0) {
+            const depthMap = this.computeJobDepths(jobs);
+            for (const jc of jobConfigs || []) {
+                const job = jobs.find(j => j.id === jc.id);
+                if (job && !job.stage) {
+                    for (const s of stages) {
+                        if (jc.id === s.name || jc.id.startsWith(s.name + '-') || jc.id.startsWith(s.name + '_')) {
+                            job.stage = s.name;
+                            break;
+                        }
+                    }
+                }
+            }
+            for (const job of jobs) {
+                if (!job.stage) {
+                    const depth = depthMap.get(job.id) || 0;
+                    job.stage = stages[Math.min(depth, stages.length - 1)].name;
+                }
+            }
+        }
+        // Apply workflow-level defaults
+        const cicd = ast.options?.cicd;
+        if (cicd) {
+            for (const job of jobs) {
+                if (cicd.variables && !job.variables) {
+                    job.variables = { ...cicd.variables };
+                }
+                if (cicd.beforeScript && !job.beforeScript) {
+                    job.beforeScript = [...cicd.beforeScript];
+                }
+                if (cicd.tags && !job.tags) {
+                    job.tags = [...cicd.tags];
+                }
+            }
+        }
         return this.topoSortJobs(jobs);
     }
-    /**
-     * Topologically sort jobs so that dependencies come first.
-     */
     topoSortJobs(jobs) {
         const jobMap = new Map(jobs.map((j) => [j.id, j]));
         const visited = new Set();
@@ -244,24 +280,40 @@ export class BaseCICDTarget extends BaseExportTarget {
         }
         return sorted;
     }
-    /**
-     * Map secret:NAME connections to the jobs that need them.
-     * Populates job.secrets and step.env for each secret connection.
-     */
+    computeJobDepths(jobs) {
+        const depths = new Map();
+        function depth(jobId, visited) {
+            if (depths.has(jobId))
+                return depths.get(jobId);
+            if (visited.has(jobId))
+                return 0;
+            visited.add(jobId);
+            const job = jobs.find(j => j.id === jobId);
+            if (!job || job.needs.length === 0) {
+                depths.set(jobId, 0);
+                return 0;
+            }
+            const maxDep = Math.max(...job.needs.map(n => depth(n, visited)));
+            const d = maxDep + 1;
+            depths.set(jobId, d);
+            return d;
+        }
+        for (const job of jobs) {
+            depth(job.id, new Set());
+        }
+        return depths;
+    }
     resolveJobSecrets(jobs, ast, renderSecretRef) {
-        // Build node -> job lookup
         const nodeJob = new Map();
         for (const inst of ast.instances) {
             nodeJob.set(inst.id, inst.job || 'default');
         }
-        // Build step lookup
         const stepMap = new Map();
         for (const job of jobs) {
             for (const step of job.steps) {
                 stepMap.set(step.id, step);
             }
         }
-        // Process secret connections
         for (const conn of ast.connections) {
             if (!conn.from.node.startsWith('secret:'))
                 continue;
@@ -274,34 +326,25 @@ export class BaseCICDTarget extends BaseExportTarget {
             const job = jobs.find((j) => j.id === jobId);
             if (!job)
                 continue;
-            // Add secret to job
             if (!job.secrets.includes(secretName)) {
                 job.secrets.push(secretName);
             }
-            // Add env var to the step
             const step = stepMap.get(targetNode);
             if (step) {
                 step.env = step.env || {};
-                // Convert port name to env var (e.g., npmToken -> NPM_TOKEN or use secret name directly)
                 step.env[targetPort.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '')] =
                     renderSecretRef(secretName);
             }
         }
     }
-    /**
-     * Add artifact upload/download steps between jobs.
-     */
     injectArtifactSteps(jobs, artifacts) {
         if (artifacts.length === 0)
             return;
-        // For each job that has dependencies, check if any dependency produces artifacts
         for (const job of jobs) {
             if (job.needs.length === 0)
                 continue;
-            // Check if any needed job produces artifacts
             const neededJobs = jobs.filter((j) => job.needs.includes(j.id));
             for (const needed of neededJobs) {
-                // Find artifacts that match the producing job
                 const jobArtifacts = artifacts.filter((a) => !a.name || needed.steps.some((s) => s.nodeType === a.name));
                 if (jobArtifacts.length > 0) {
                     needed.uploadArtifacts = (needed.uploadArtifacts || []).concat(jobArtifacts);
@@ -310,9 +353,6 @@ export class BaseCICDTarget extends BaseExportTarget {
             }
         }
     }
-    /**
-     * Generate SECRETS_SETUP.md with per-secret setup instructions.
-     */
     generateSecretsDoc(secrets, platform) {
         if (secrets.length === 0)
             return '';
@@ -354,4 +394,4 @@ export class BaseCICDTarget extends BaseExportTarget {
         return lines.join('\n');
     }
 }
-//# sourceMappingURL=cicd-base.js.map
+//# sourceMappingURL=base-target.js.map

package/dist/{validation/cicd-detection.d.ts → extensions/cicd/detection.d.ts}

@@ -6,7 +6,7 @@
  * @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';
+import type { TWorkflowAST } from '../../ast/types.js';
 /**
  * Check if a workflow is a CI/CD pipeline.
  *
@@ -30,4 +30,4 @@ export declare function getDeclaredSecrets(ast: TWorkflowAST): string[];
  * Returns array of secret names that are wired via @connect.
  */
 export declare function getReferencedSecrets(ast: TWorkflowAST): string[];
-//# sourceMappingURL=cicd-detection.d.ts.map
+//# sourceMappingURL=detection.d.ts.map

package/dist/{validation/cicd-detection.js → extensions/cicd/detection.js}

@@ -36,6 +36,18 @@ export function isCICDWorkflow(ast) {
             return true;
         if (cicd.triggers && cicd.triggers.length > 0)
             return true;
+        if (cicd.jobs && cicd.jobs.length > 0)
+            return true;
+        if (cicd.variables && Object.keys(cicd.variables).length > 0)
+            return true;
+        if (cicd.beforeScript && cicd.beforeScript.length > 0)
+            return true;
+        if (cicd.tags && cicd.tags.length > 0)
+            return true;
+        if (cicd.includes && cicd.includes.length > 0)
+            return true;
+        if (cicd.stages && cicd.stages.length > 0)
+            return true;
     }
     // Check node-level CI/CD annotations
     if (ast.instances.some((inst) => inst.job))
@@ -73,4 +85,4 @@ export function getReferencedSecrets(ast) {
     }
     return Array.from(secrets);
 }
-//# sourceMappingURL=cicd-detection.js.map
+//# sourceMappingURL=detection.js.map