@synergenius/flowweaver-pack-gitlab-ci 0.1.1

package/LICENSE

@@ -0,0 +1,204 @@
+Flow Weaver Library License
+
+Version 2.0, February 2026
+
+## Quick Reference (non-binding summary)
+
+This table is provided for convenience only. In case of any conflict between
+this summary and the license terms below, the license terms control.
+
+Permitted:
+
+  Use                                       Who               Notes
+  ----------------------------------------  ----------------  ----------------------------------
+  Install and run locally                   Anyone            No restrictions on local use
+  Compile workflows                         Anyone            CLI, programmatic, scripts
+  Use generated output (code, artifacts)    Anyone            Output is unrestricted
+  Run in CI/CD pipelines and build systems  Anyone, any size  Not considered "hosting"
+  Distribute copies with license notices    Anyone            Must include license, mark changes
+  Create derivative works                   Anyone            Must retain license key checks
+  Host internally                           Orgs <= 15        All members count toward limit
+  Embed in internal toolchains              Anyone            No visual workflow authoring UI
+  Use inside a larger product                Anyone            If flow-weaver is not the primary value
+
+Requires commercial license:
+
+  Use                                       Notes
+  ----------------------------------------  ----------------------------------
+  Host internally                           Orgs > 15 people
+  Build visual workflow authoring tools     Standalone products for workflow authoring
+  Offer as a hosted or managed service      To third parties, at any scale
+  Sell products built on the software       Where flow-weaver is the primary value
+
+Never permitted:
+
+  Use                                       Notes
+  ----------------------------------------  ----------------------------------
+  Remove or circumvent license keys         Applies to software and derivatives
+  Remove licensing or copyright notices     Must always be retained
+  Strip license key checks from forks       Derivatives must retain protections
+
+---
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any of the features or
+functionality of the software.
+
+You may not use the software to build, distribute, or offer any standalone
+product or service whose primary purpose is providing a graphical or visual
+interface for creating, editing, designing, or composing workflows. This
+restriction applies whether the product is hosted, distributed, sold, or offered
+free of charge. It does not apply to products that use the software internally
+without exposing its workflow authoring capabilities to end users through a
+graphical interface.
+
+You may not sell the software or any product that provides, as its primary
+function, capabilities supplied by the software (including workflow compilation,
+parsing, validation, code generation, or diagram generation), without a separate
+commercial license from the licensor. This does not restrict the sale of products
+that merely incorporate the software as one component among many, where the
+product's primary value comes from functionality independent of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+Derivative works must retain all license key functionality, license verification
+mechanisms, and licensing notices present in the original software. Distributing
+derivative works with license key protections removed, disabled, or bypassed
+constitutes a violation of this license.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor's trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to the
+software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate immediately.
+
+You may request a review of any termination by contacting the licensor in
+writing within 15 days of termination. The licensor will respond within 30 days.
+
+## No Liability
+
+As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.
+
+## Governing Law
+
+This license is governed by the laws of Portugal. Any disputes arising from or
+related to this license will be submitted to the exclusive jurisdiction of the
+courts of Lisbon, Portugal.
+
+## Definitions
+
+The "licensor" is Ricardo Jose Horta Morais (Synergenius), and the "software"
+is the software the licensor makes available under these terms.
+
+"You" refers to the individual or entity agreeing to these terms. "Your company"
+is any legal entity, sole proprietorship, or other kind of organization that you
+work for, plus all organizations that have control over, are under the control
+of, or are under common control with that organization. "Control" means
+ownership of substantially all the assets of an entity, or the power to direct
+its management and policies by vote, contract, or otherwise. Control can be
+direct or indirect.
+
+"Third parties" means any individual or entity that is not you or your company
+as defined in these terms.
+
+"Your licenses" are all the licenses granted to you for the software under these
+terms. "Use" means anything you do with the software requiring one of your
+licenses.
+
+"Hosting the software" means making the software's functionality available to
+users over a network as a service. Running the software in automated build
+pipelines, continuous integration systems, command-line interfaces, or
+development toolchains does not constitute hosting, regardless of organization
+size.
+
+---
+
+ADDITIONAL NOTICES
+
+1. Output of the Software
+
+The output of the software, including but not limited to compiled workflows,
+generated code, deployment artifacts, and any other files produced by the
+software's compilation, code generation, or export features, is not considered
+part of the software and may be used, copied, modified, distributed, and
+sublicensed for any purpose without restriction under this license.
+
+2. Internal Hosting Threshold
+
+Organizations with 15 or fewer individuals, including employees, contractors,
+and affiliates, may host the software on internal infrastructure for use by
+their members without restriction under this license. The count includes all
+individuals in the organization, not only those who directly use the software.
+
+Organizations with more than 15 individuals that wish to host the software,
+whether on internal infrastructure or as a service, require a commercial
+license.
+
+3. Unrestricted Use
+
+Using the software locally, including installing, running, compiling workflows,
+generating code, and producing deployment artifacts, is permitted for any
+individual or organization regardless of size, subject to the Limitations above.
+
+4. Export Compliance
+
+You are responsible for compliance with all applicable export and import laws
+and regulations in your jurisdiction when using, distributing, or making the
+software available.
+
+5. Commercial Licensing
+
+For commercial licensing inquiries, partnership arrangements, or questions
+about permitted use, contact support@synergenius.pt.

package/dist/target.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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 { BaseCICDTarget } from '@synergenius/flow-weaver/deployment';
+import type { ExportOptions, ExportArtifacts, DeployInstructions } from '@synergenius/flow-weaver/deployment';
+export declare class GitLabCITarget extends BaseCICDTarget {
+    readonly name = "gitlab-ci";
+    readonly description = "GitLab CI/CD pipeline (.gitlab-ci.yml)";
+    readonly deploySchema: {
+        runner: {
+            type: "string";
+            description: string;
+            default: string;
+        };
+    };
+    readonly nodeTypeDeploySchema: {
+        script: {
+            type: "string[]";
+            description: string;
+        };
+        image: {
+            type: "string";
+            description: string;
+        };
+        label: {
+            type: "string";
+            description: string;
+        };
+    };
+    generate(options: ExportOptions): Promise<ExportArtifacts>;
+    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.
+     */
+    private deriveStages;
+    /**
+     * Derive default image from @deploy annotations or built-in mappings.
+     */
+    private deriveDefaultImage;
+    /**
+     * Convert CI/CD triggers to GitLab CI workflow rules.
+     */
+    private renderWorkflowRules;
+    private renderJob;
+    private renderStepScript;
+    private renderCache;
+    /**
+     * Apply workflow-level options to jobs.
+     */
+    private applyWorkflowOptions;
+}
+export default GitLabCITarget;

package/dist/target.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 '@synergenius/flow-weaver/deployment';
+import { BaseCICDTarget, } from '@synergenius/flow-weaver/deployment';
+import { parseWorkflow } from '@synergenius/flow-weaver/api';
+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;
+            }
+        }
+    }
+}
+export default GitLabCITarget;

package/flowweaver.manifest.json

@@ -0,0 +1,15 @@
+{
+  "manifestVersion": 1,
+  "name": "@synergenius/flowweaver-pack-gitlab-ci",
+  "version": "0.1.1",
+  "nodeTypes": [],
+  "workflows": [],
+  "patterns": [],
+  "exportTargets": [
+    {
+      "name": "gitlab-ci",
+      "description": "GitLab CI/CD pipeline generation",
+      "file": "dist/target.js"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@synergenius/flowweaver-pack-gitlab-ci",
+  "version": "0.1.1",
+  "description": "GitLab CI/CD export target for Flow Weaver",
+  "keywords": [
+    "flowweaver-marketplace-pack",
+    "flow-weaver",
+    "gitlab-ci",
+    "cicd"
+  ],
+  "flowWeaver": {
+    "type": "marketplace-pack",
+    "engineVersion": ">=0.14.0",
+    "categories": [
+      "deployment",
+      "cicd"
+    ]
+  },
+  "peerDependencies": {
+    "@synergenius/flow-weaver": ">=0.14.0"
+  },
+  "dependencies": {
+    "yaml": "^2.8.0"
+  },
+  "main": "./dist/target.js",
+  "types": "./dist/target.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "flowweaver.manifest.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@synergenius/flow-weaver": "^0.14.2",
+    "@types/node": "^20.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/synergenius-fw/flowweaver-pack-gitlab-ci.git"
+  }
+}