@synergenius/flowweaver-pack-gitlab-ci 0.1.2 → 0.1.4

package/dist/target.d.ts

@@ -17,6 +17,8 @@ import type { ExportOptions, ExportArtifacts, DeployInstructions } from '@synerg
 export declare class GitLabCITarget extends BaseCICDTarget {
     readonly name = "gitlab-ci";
     readonly description = "GitLab CI/CD pipeline (.gitlab-ci.yml)";
+    /** Accumulated warnings for the current export run */
+    private _warnings;
     readonly deploySchema: {
         runner: {
             type: "string";
@@ -42,14 +44,25 @@ export declare class GitLabCITarget extends BaseCICDTarget {
     getDeployInstructions(_artifacts: ExportArtifacts): DeployInstructions;
     private renderPipelineYAML;
     /**
-     * Derive stages from job dependency order.
-     * Jobs with no deps → stage 1, jobs depending on stage 1 → stage 2, etc.
+     * Derive stages from @stage annotations or job dependency depth.
+     *
+     * When @stage annotations exist, jobs are grouped into named stages:
+     * - Jobs with an explicit `stage` field (set by buildJobGraph from @stage/@job)
+     *   use that stage name directly.
+     * - The returned list preserves @stage declaration order.
+     *
+     * Without @stage annotations, falls back to using each job ID as its own stage
+     * (ordered by dependency).
      */
     private deriveStages;
     /**
-     * Derive default image from @deploy annotations or built-in mappings.
+     * Derive default image from @runner annotation, @deploy annotations, or built-in mappings.
      */
     private deriveDefaultImage;
+    /**
+     * Map GitHub-style runner labels to Docker images.
+     */
+    private mapRunnerToImage;
     /**
      * Convert CI/CD triggers to GitLab CI workflow rules.
      */

package/dist/target.js

@@ -20,6 +20,8 @@ import * as path from 'path';
 export class GitLabCITarget extends BaseCICDTarget {
     name = 'gitlab-ci';
     description = 'GitLab CI/CD pipeline (.gitlab-ci.yml)';
+    /** Accumulated warnings for the current export run */
+    _warnings = [];
     deploySchema = {
         runner: { type: 'string', description: 'Default Docker image', default: 'ubuntu:latest' },
     };
@@ -29,6 +31,7 @@ export class GitLabCITarget extends BaseCICDTarget {
         label: { type: 'string', description: 'Step display name' },
     };
     async generate(options) {
+        this._warnings = [];
         const filePath = path.resolve(options.sourceFile);
         const outputDir = path.resolve(options.outputDir);
         // Parse the workflow file to get AST
@@ -64,11 +67,18 @@ export class GitLabCITarget extends BaseCICDTarget {
                 files.push(this.createFile(outputDir, 'SECRETS_SETUP.md', secretsDoc, 'other'));
             }
         }
+        // Warn about @concurrency (no direct GitLab equivalent)
+        for (const ast of targetWorkflows) {
+            if (ast.options?.cicd?.concurrency) {
+                this._warnings.push(`@concurrency: GitLab CI has no direct concurrency group equivalent. Use resource_group for serial execution or interruptible for auto-cancellation.`);
+            }
+        }
         return {
             files,
             target: this.name,
             workflowName: options.displayName || targetWorkflows[0].name,
             entryPoint: files[0].relativePath,
+            warnings: this._warnings.length > 0 ? this._warnings : undefined,
         };
     }
     getDeployInstructions(_artifacts) {
@@ -99,14 +109,40 @@ export class GitLabCITarget extends BaseCICDTarget {
     // ---------------------------------------------------------------------------
     renderPipelineYAML(ast, jobs) {
         const doc = {};
-        // stages (derived from job dependency order)
-        const stages = this.deriveStages(jobs);
+        // include: directive (from @includes)
+        const includes = ast.options?.cicd?.includes;
+        if (includes && includes.length > 0) {
+            doc.include = includes.map(inc => {
+                switch (inc.type) {
+                    case 'local': return { local: inc.file };
+                    case 'template': return { template: inc.file };
+                    case 'remote': return { remote: inc.file };
+                    case 'project': {
+                        const obj = { project: inc.project || '', file: inc.file };
+                        if (inc.ref)
+                            obj.ref = inc.ref;
+                        return obj;
+                    }
+                    default: return { local: inc.file };
+                }
+            });
+        }
+        // stages (from @stage annotations or derived from dependency depth)
+        const stages = this.deriveStages(jobs, ast);
         doc.stages = stages;
         // Default image
         const defaultImage = this.deriveDefaultImage(ast, jobs);
         if (defaultImage) {
             doc.default = { image: defaultImage };
         }
+        // Workflow-level variables
+        if (ast.options?.cicd?.variables && Object.keys(ast.options.cicd.variables).length > 0) {
+            doc.variables = { ...ast.options.cicd.variables };
+        }
+        // Workflow-level before_script
+        if (ast.options?.cicd?.beforeScript && ast.options.cicd.beforeScript.length > 0) {
+            doc.before_script = ast.options.cicd.beforeScript;
+        }
         // Workflow-level rules (from triggers)
         const rules = this.renderWorkflowRules(ast.options?.cicd?.triggers || []);
         if (rules.length > 0) {
@@ -123,29 +159,32 @@ export class GitLabCITarget extends BaseCICDTarget {
         });
     }
     /**
-     * Derive stages from job dependency order.
-     * Jobs with no deps → stage 1, jobs depending on stage 1 → stage 2, etc.
+     * Derive stages from @stage annotations or job dependency depth.
+     *
+     * When @stage annotations exist, jobs are grouped into named stages:
+     * - Jobs with an explicit `stage` field (set by buildJobGraph from @stage/@job)
+     *   use that stage name directly.
+     * - The returned list preserves @stage declaration order.
+     *
+     * Without @stage annotations, falls back to using each job ID as its own stage
+     * (ordered by dependency).
      */
-    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;
+    deriveStages(jobs, ast) {
+        const declaredStages = ast?.options?.cicd?.stages;
+        // If @stage annotations exist, use them
+        if (declaredStages && declaredStages.length > 0) {
+            const stageNames = declaredStages.map(s => s.name);
+            // Collect any stages referenced by jobs that aren't in the declared list
+            for (const job of jobs) {
+                if (job.stage && !stageNames.includes(job.stage)) {
+                    stageNames.push(job.stage);
+                }
             }
-            // Stage is one after the latest dependency
-            const depStages = job.needs.map((dep) => getStage(dep, jobs));
-            assigned.set(jobId, jobId);
-            return jobId;
+            return stageNames;
         }
-        // Simple: use job IDs as stage names, ordered by dependency
+        // Fallback: use job IDs as stage names, ordered by dependency
+        const stages = [];
         for (const job of jobs) {
-            getStage(job.id, jobs);
             if (!stages.includes(job.id)) {
                 stages.push(job.id);
             }
@@ -153,10 +192,15 @@ export class GitLabCITarget extends BaseCICDTarget {
         return stages;
     }
     /**
-     * Derive default image from @deploy annotations or built-in mappings.
+     * Derive default image from @runner annotation, @deploy annotations, or built-in mappings.
      */
-    deriveDefaultImage(_ast, jobs) {
-        // Check steps for @deploy gitlab-ci image or built-in mapping
+    deriveDefaultImage(ast, jobs) {
+        // Check @runner annotation first
+        const runner = ast.options?.cicd?.runner;
+        if (runner) {
+            return this.mapRunnerToImage(runner);
+        }
+        // Fall back to NODE_ACTION_MAP step images
         for (const job of jobs) {
             for (const step of job.steps) {
                 const mapping = this.resolveActionMapping(step, 'gitlab-ci');
@@ -166,6 +210,17 @@ export class GitLabCITarget extends BaseCICDTarget {
         }
         return undefined;
     }
+    /**
+     * Map GitHub-style runner labels to Docker images.
+     */
+    mapRunnerToImage(runner) {
+        const imageMap = {
+            'ubuntu-latest': 'ubuntu:latest',
+            'ubuntu-22.04': 'ubuntu:22.04',
+            'ubuntu-20.04': 'ubuntu:20.04',
+        };
+        return imageMap[runner] || runner;
+    }
     /**
      * Convert CI/CD triggers to GitLab CI workflow rules.
      */
@@ -215,24 +270,72 @@ export class GitLabCITarget extends BaseCICDTarget {
     }
     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;
+        // extends (from @job extends=".template-name")
+        if (job.extends) {
+            jobObj.extends = job.extends;
+        }
+        // stage (use explicit stage from @stage assignment, or fall back to job ID)
+        jobObj.stage = job.stage || job.id;
+        // image (from per-job runner override via @job X runner=Y)
+        if (job.runner) {
+            jobObj.image = this.mapRunnerToImage(job.runner);
+        }
+        // tags (from @job tags or @tags)
+        if (job.tags && job.tags.length > 0) {
+            jobObj.tags = job.tags;
+        }
+        // matrix strategy (parallel: matrix:)
+        if (job.matrix) {
+            const matrixEntries = [];
+            if (job.matrix.dimensions && Object.keys(job.matrix.dimensions).length > 0) {
+                matrixEntries.push(job.matrix.dimensions);
+            }
+            if (job.matrix.include) {
+                for (const inc of job.matrix.include) {
+                    matrixEntries.push(Object.fromEntries(Object.entries(inc).map(([k, v]) => [k, [v]])));
+                }
+            }
+            if (matrixEntries.length > 0) {
+                jobObj.parallel = { matrix: matrixEntries };
+            }
         }
         // needs (for DAG mode instead of stage-based ordering)
         if (job.needs.length > 0) {
             jobObj.needs = job.needs;
         }
+        // retry (from @job retry)
+        if (job.retry !== undefined) {
+            jobObj.retry = { max: job.retry };
+        }
+        // allow_failure (from @job allow_failure)
+        if (job.allowFailure) {
+            jobObj.allow_failure = true;
+        }
+        // timeout (from @job timeout)
+        if (job.timeout) {
+            jobObj.timeout = job.timeout;
+        }
+        // rules (from @job rules)
+        if (job.rules && job.rules.length > 0) {
+            jobObj.rules = job.rules.map(rule => {
+                const ruleObj = {};
+                if (rule.if)
+                    ruleObj.if = rule.if;
+                if (rule.when)
+                    ruleObj.when = rule.when;
+                if (rule.allowFailure)
+                    ruleObj.allow_failure = true;
+                if (rule.changes)
+                    ruleObj.changes = rule.changes;
+                if (rule.variables)
+                    ruleObj.variables = rule.variables;
+                return ruleObj;
+            });
+        }
+        // coverage (from @job coverage)
+        if (job.coverage) {
+            jobObj.coverage = job.coverage;
+        }
         // environment
         if (job.environment) {
             const envConfig = ast.options?.cicd?.environments?.find((e) => e.name === job.environment);
@@ -242,7 +345,6 @@ export class GitLabCITarget extends BaseCICDTarget {
             if (envConfig?.reviewers)
                 envObj.deployment_tier = 'production';
             jobObj.environment = envObj;
-            // Protected environments require manual approval in GitLab
             if (envConfig?.reviewers) {
                 jobObj.when = 'manual';
             }
@@ -251,46 +353,54 @@ export class GitLabCITarget extends BaseCICDTarget {
         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)
+        // variables (merge secrets + job-level variables)
+        const variables = {};
         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}`;
             }
+        }
+        if (job.variables) {
+            Object.assign(variables, job.variables);
+        }
+        if (Object.keys(variables).length > 0) {
             jobObj.variables = variables;
         }
+        // before_script (from @job or @before_script)
+        if (job.beforeScript && job.beforeScript.length > 0) {
+            jobObj.before_script = job.beforeScript;
+        }
         // cache
         if (job.cache) {
             jobObj.cache = this.renderCache(job.cache);
         }
-        // artifacts (upload)
+        // artifacts (upload + reports)
+        const artifactsObj = {};
         if (job.uploadArtifacts && job.uploadArtifacts.length > 0) {
-            const paths = job.uploadArtifacts.map((a) => a.path);
+            artifactsObj.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,
-            };
+            artifactsObj.expire_in = expiry;
+        }
+        if (job.reports && job.reports.length > 0) {
+            const reports = {};
+            for (const report of job.reports) {
+                reports[report.type] = report.path;
+            }
+            artifactsObj.reports = reports;
+        }
+        if (Object.keys(artifactsObj).length > 0) {
+            jobObj.artifacts = artifactsObj;
         }
         // 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flowweaver-pack-gitlab-ci",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "GitLab CI/CD export target for Flow Weaver",
   "keywords": [
     "flowweaver-marketplace-pack",
@@ -35,9 +35,9 @@
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "@synergenius/flow-weaver": "^0.17.1",
-    "@types/node": "^20.0.0"
+    "@synergenius/flow-weaver": "^0.17.4",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
   },
   "license": "SEE LICENSE IN LICENSE",
   "repository": {