structkit 3.0.0__py3-none-any.whl

structkit/content_fetcher.py

@@ -0,0 +1,249 @@
+# FILE: content_fetcher.py
+import os
+import re
+import requests
+import subprocess
+from pathlib import Path
+import hashlib
+import logging
+
+try:
+  import boto3
+  from botocore.exceptions import NoCredentialsError, ClientError
+  boto3_available = True
+except ImportError:
+  boto3_available = False
+
+try:
+  from google.cloud import storage
+  from google.api_core.exceptions import GoogleAPIError
+  gcs_available = True
+except ImportError:
+  gcs_available = False
+
+class ContentFetcher:
+  def __init__(self, cache_dir=None):
+    self.logger = logging.getLogger(__name__)
+    self.cache_dir = Path(cache_dir or os.path.expanduser("~/.struct/cache"))
+    self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+  def fetch_content(self, content_location):
+    """
+    Fetch content from a given location. Supported protocols:
+    - Local file (file://)
+    - HTTP/HTTPS (https://)
+    - GitHub repository (github://owner/repo/branch/file_path)
+    - GitHub HTTPS (githubhttps://owner/repo/branch/file_path)
+    - GitHub SSH (githubssh://owner/repo/branch/file_path)
+    - S3 bucket (s3://bucket_name/key)
+    - Google Cloud Storage (gs://bucket_name/key)
+    """
+    protocol_map = {
+      "file://": self._fetch_local_file,
+      "https://": self._fetch_http_url,
+      "github://": self._fetch_github_file,
+      "githubhttps://": self._fetch_github_https_file,
+      "githubssh://": self._fetch_github_ssh_file,
+    }
+
+    if boto3_available:
+      protocol_map["s3://"] = self._fetch_s3_file
+    if gcs_available:
+      protocol_map["gs://"] = self._fetch_gcs_file
+
+    for prefix, method in protocol_map.items():
+      if content_location.startswith(prefix):
+        # Only treat the raw HTTPS prefix as a direct URL fetch. All other
+        # custom prefixes (e.g., githubhttps://, githubssh://) should have
+        # their prefix stripped and be dispatched to the appropriate handler.
+        if prefix == "https://":
+          return method(content_location)
+        else:
+          return method(content_location[len(prefix):])
+
+    raise ValueError(f"Unsupported content location: {content_location}")
+
+  def _fetch_local_file(self, file_path):
+    self.logger.debug(f"Fetching content from local file: {file_path}")
+    file_path = Path(file_path)
+    with file_path.open('r') as file:
+      return file.read()
+
+  def _fetch_http_url(self, url):
+    self.logger.debug(f"Fetching content from URL: {url}")
+    # Create a hash of the URL to use as a cache key
+    cache_key = hashlib.md5(url.encode()).hexdigest()
+    cache_file_path = self.cache_dir / cache_key
+
+    if cache_file_path.exists():
+      self.logger.debug(f"Loading content from cache: {cache_file_path}")
+      with cache_file_path.open('r') as file:
+        return file.read()
+
+    response = requests.get(url)
+    response.raise_for_status()
+    with cache_file_path.open('w') as file:
+      file.write(response.text)
+
+    return response.text
+
+  def _fetch_github_file(self, github_path):
+    """
+    Fetch a file from a GitHub repository using HTTPS.
+    Dispatcher passes: owner/repo/branch/file_path
+    """
+    self.logger.debug(f"Fetching content from GitHub: {github_path}")
+    match = re.match(r"([^/]+)/([^/]+)/([^/]+)/(.+)", github_path)
+    if not match:
+      raise ValueError("Invalid GitHub path. Expected owner/repo/branch/file_path")
+
+    owner, repo, branch, file_path = match.groups()
+    return self._github_fetch_with_raw_then_git(owner, repo, branch, file_path, use_https=True)
+
+  def _fetch_github_https_file(self, github_path):
+    """
+    Fetch a file from a GitHub repository using HTTPS.
+    Dispatcher passes: owner/repo/branch/file_path
+    """
+    self.logger.debug(f"Fetching content from GitHub (HTTPS): {github_path}")
+    match = re.match(r"([^/]+)/([^/]+)/([^/]+)/(.+)", github_path)
+    if not match:
+      raise ValueError("Invalid GitHub path. Expected owner/repo/branch/file_path")
+
+    owner, repo, branch, file_path = match.groups()
+    return self._github_fetch_with_raw_then_git(owner, repo, branch, file_path, use_https=True)
+
+  def _fetch_github_ssh_file(self, github_path):
+    """
+    Fetch a file from a GitHub repository using SSH.
+    Dispatcher passes: owner/repo/branch/file_path
+    """
+    self.logger.debug(f"Fetching content from GitHub (SSH): {github_path}")
+    match = re.match(r"([^/]+)/([^/]+)/([^/]+)/(.+)", github_path)
+    if not match:
+      raise ValueError("Invalid GitHub path. Expected owner/repo/branch/file_path")
+
+    owner, repo, branch, file_path = match.groups()
+    return self._github_fetch_with_raw_then_git(owner, repo, branch, file_path, use_https=False)
+
+  def _clone_or_fetch_github(self, owner, repo, branch, file_path, https=True):
+    repo_cache_path = self.cache_dir / f"{owner}_{repo}_{branch}"
+    clone_url = f"https://github.com/{owner}/{repo}.git" if https else f"git@github.com:{owner}/{repo}.git"
+
+    # Clone or fetch the repository
+    if not repo_cache_path.exists():
+      self.logger.debug(f"Cloning repository: {owner}/{repo} (branch: {branch})")
+      subprocess.run(["git", "clone", "-b", branch, clone_url, str(repo_cache_path)], check=True)
+    else:
+      self.logger.debug(f"Repository already cloned. Pulling latest changes for: {repo_cache_path}")
+      subprocess.run(["git", "-C", str(repo_cache_path), "pull"], check=True)
+
+    # Read the requested file
+    file_full_path = repo_cache_path / file_path
+    if not file_full_path.exists():
+      raise FileNotFoundError(f"File {file_path} not found in repository {owner}/{repo} on branch {branch}")
+
+    with file_full_path.open('r') as file:
+      return file.read()
+
+  def _github_fetch_with_raw_then_git(self, owner, repo, branch, file_path, use_https=True):
+    """
+    Try lightweight fetch via raw.githubusercontent.com first. If it fails
+    (network disabled, HTTP error, etc.), fall back to git clone/pull.
+    If a local cache repo exists already, prefer using git path directly
+    to avoid surprise network requests.
+    """
+    # Deny network option
+    if os.getenv("STRUCTKIT_DENY_NETWORK") == "1":
+      self.logger.debug("Network denied by STRUCTKIT_DENY_NETWORK=1; using git fallback if available")
+      return self._clone_or_fetch_github(owner, repo, branch, file_path, https=use_https)
+
+    repo_cache_path = self.cache_dir / f"{owner}_{repo}_{branch}"
+    if repo_cache_path.exists():
+      # Keep existing behavior: use git path if cache exists
+      return self._clone_or_fetch_github(owner, repo, branch, file_path, https=use_https)
+
+    # Attempt raw fetch
+    raw_url = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{file_path}"
+    timeout = float(os.getenv("STRUCTKIT_HTTP_TIMEOUT", "10"))
+    retries = int(os.getenv("STRUCTKIT_HTTP_RETRIES", "2"))
+
+    last_err = None
+    for attempt in range(retries + 1):
+      try:
+        self.logger.debug(f"Attempting raw fetch: {raw_url} (attempt {attempt+1}/{retries+1})")
+        resp = requests.get(raw_url, timeout=timeout)
+        resp.raise_for_status()
+        return resp.text
+      except Exception as e:
+        last_err = e
+        # simple backoff
+        try:
+          import time
+          time.sleep(min(2 ** attempt, 5))
+        except Exception:
+          pass
+
+    self.logger.warning(f"Raw GitHub fetch failed, falling back to git. Last error: {last_err}")
+    return self._clone_or_fetch_github(owner, repo, branch, file_path, https=use_https)
+
+  def _fetch_s3_file(self, s3_path):
+    """
+    Fetch a file from an S3 bucket.
+    Dispatcher passes: bucket_name/key
+    """
+    if not boto3_available:
+      raise ImportError("boto3 is not installed. Please install it to use S3 fetching.")
+
+    self.logger.debug(f"Fetching content from S3: {s3_path}")
+    match = re.match(r"([^/]+)/(.+)", s3_path)
+    if not match:
+      raise ValueError("Invalid S3 path. Expected bucket_name/key")
+
+    bucket_name, key = match.groups()
+    local_file_path = self.cache_dir / Path(key).name
+
+    try:
+      session = boto3.Session()  # Create a new session
+      s3_client = session.client("s3")
+      s3_client.download_file(bucket_name, key, str(local_file_path))
+      self.logger.debug(f"Downloaded S3 file to: {local_file_path}")
+    except NoCredentialsError:
+      raise RuntimeError("AWS credentials not found. Ensure that your credentials are configured properly.")
+    except ClientError as e:
+      error_code = e.response.get("Error", {}).get("Code")
+      if error_code == "404":
+        raise FileNotFoundError(f"The specified S3 key does not exist: {key}")
+      else:
+        raise RuntimeError(f"Failed to download S3 file: {e}")
+
+    with local_file_path.open('r') as file:
+      return file.read()
+
+  def _fetch_gcs_file(self, gcs_path):
+    """
+    Fetch a file from Google Cloud Storage.
+    Dispatcher passes: bucket_name/key
+    """
+    if not gcs_available:
+      raise ImportError("google-cloud-storage is not installed. Please install it to use GCS fetching.")
+
+    self.logger.debug(f"Fetching content from GCS: {gcs_path}")
+    match = re.match(r"([^/]+)/(.+)", gcs_path)
+    if not match:
+      raise ValueError("Invalid GCS path. Expected bucket_name/key")
+
+    bucket_name, key = match.groups()
+    local_file_path = self.cache_dir / Path(key).name
+
+    try:
+      gcs_client = storage.Client()
+      bucket = gcs_client.bucket(bucket_name)
+      blob = bucket.blob(key)
+      blob.download_to_filename(str(local_file_path))
+      self.logger.debug(f"Downloaded GCS file to: {local_file_path}")
+    except GoogleAPIError as e:
+      raise RuntimeError(f"Failed to download GCS file: {e}")
+
+    with local_file_path.open('r') as file:
+      return file.read()

structkit/contribs/README.md

@@ -0,0 +1,271 @@
+# Contribs Sub-Structs
+
+The `contribs` folder contains various sub-structs that can be used to generate specific project structures or configurations. Below is a list of all the YAML files in this folder, along with a brief description of what they do and when to use them.
+
+## Table of content
+
+## Table of Contents
+
+- [Contribs Sub-Structs](#contribs-sub-structs)
+  - [Sub-Structs](#sub-structs)
+    - [General](#general)
+      - [`ansible-playbook`](#ansible-playbook)
+      - [`chef-cookbook`](#chef-cookbook)
+      - [`ci-cd-pipelines`](#ci-cd-pipelines)
+      - [`cloudformation-files`](#cloudformation-files)
+      - [`docker-files`](#docker-files)
+      - [`documentation-template`](#documentation-template)
+      - [`git-hooks`](#git-hooks)
+      - [`helm-chart`](#helm-chart)
+      - [`kubernetes-manifests`](#kubernetes-manifests)
+      - [`vagrant-files`](#vagrant-files)
+    - [Configs](#configs)
+      - [`configs/codeowners`](#configscodeowners)
+      - [`configs/devcontainer`](#configsdevcontainer)
+      - [`configs/editor-config`](#configseditor-config)
+      - [`configs/eslint`](#configseslint)
+      - [`configs/jshint`](#configsjshint)
+      - [`configs/prettier`](#configsprettier)
+    - [Github](#github)
+      - [`github/workflows/execute-tf-workflow`](#githubworkflowsexecute-tf-workflow)
+      - [`github/workflows/pre-commit`](#githubworkflowspre-commit)
+      - [`github/workflows/labeler`](#githubworkflowslabeler)
+      - [`github/workflows/release-drafter`](#githubworkflowsrelease-drafter)
+      - [`github/workflows/run-struct`](#githubworkflowsrun-struct)
+      - [`github/workflows/stale`](#githubworkflowsstale)
+      - [`github/templates`](#githubtemplates)
+      - [`github/prompts/generic`](#githubpromptsgeneric)
+      - [`github/prompts/react-form`](#githubpromptsreact-form)
+      - [`github/prompts/security-api`](#githubpromptssecurity-api)
+      - [`github/prompts/struct`](#githubpromptsstruct)
+    - [Project](#project)
+      - [`project/generic`](#projectgeneric)
+      - [`project/java`](#projectjava)
+      - [`project/nodejs`](#projectnodejs)
+      - [`project/rust`](#projectrust)
+      - [`project/python`](#projectpython)
+      - [`project/go`](#projectgo)
+      - [`project/ruby`](#projectruby)
+    - [Terraform](#terraform)
+      - [`terraform/modules/generic`](#terraformmodulesgeneric)
+      - [`terraform/apps/generic`](#terraformappsgeneric)
+      - [`terraform/apps/aws-accounts`](#terraformappsaws-accounts)
+      - [`terraform/apps/github-organization`](#terraformappsgithub-organization)
+      - [`terraform/apps/environments`](#terraformappsenvironments)
+      - [`terraform/apps/init`](#terraformappsinit)
+
+## Sub-Structs
+
+### General
+
+#### `ansible-playbook`
+
+- **Description**: Generates a basic structure for an Ansible playbook, including tasks, variables, handlers, and templates.
+- **When to Use**: Use this sub-structkit when you need to create an Ansible playbook for automating infrastructure or application deployments.
+
+#### `chef-cookbook`
+
+- **Description**: Creates a Chef cookbook structure with recipes, attributes, templates, and files.
+- **When to Use**: Use this sub-structkit when you need to create a Chef cookbook for automating infrastructure or application deployments.
+
+#### `ci-cd-pipelines`
+
+- **Description**: Provides a structure for setting up CI/CD pipelines.
+- **When to Use**: this sub-structkit should only be used as a reference for setting up CI/CD pipelines.
+
+#### `cloudformation-files`
+
+- **Description**: Generates a basic structure for AWS CloudFormation templates, including a deployment script and parameters file.
+- **When to Use**: Use this sub-structkit when you need to define and deploy AWS infrastructure using CloudFormation.
+
+#### `docker-files`
+
+- **Description**: Creates a structure for Docker-related files, such as Dockerfiles and docker-compose configurations.
+- **When to Use**: Use this sub-structkit when you need to define and build Docker images for your application. Another use case is when you need to define and run multi-container applications using Docker Compose.
+
+#### `documentation-template`
+
+- **Description**: Provides a template for project documentation.
+- **Description**: This sub-structkit is useful when you need to create a documentation structure for your project.
+
+#### `git-hooks`
+
+- **Description**: Sets up Git hooks, such as pre-commit, pre-push, and commit-msg hooks.
+- **When to Use**: Use this sub-structkit when you need to enforce custom Git workflows or validations.
+
+#### `helm-chart`
+
+- **Description**: Generates a Helm chart structure for Kubernetes deployments, including templates and configuration files.
+- **When to Use**: Use this sub-structkit when you need to deploy applications to Kubernetes using Helm.
+
+#### `kubernetes-manifests`
+
+- **Description**: Creates a structure for Kubernetes manifests, such as deployments, services, and ingress configurations.
+- **When to Use**: Use this sub-structkit when you need to define and deploy Kubernetes resources for your application.
+
+#### `vagrant-files`
+
+- **Description**: Provides a structure for setting up a Vagrant development environment, including a Vagrantfile and provisioning scripts.
+- **When to Use**: Use this sub-structkit when you need to create a Vagrant development environment for your project.
+
+### Configs
+
+#### `configs/codeowners`
+
+- **Description**: Provides a template for the `.github/CODEOWNERS` file.
+- **When to Use**: Use this sub-structkit when you need to define code owners for your project's repository.
+
+#### `configs/devcontainer`
+
+- **Description**: Provides a template for the `.devcontainer` folder, which contains configuration files for Visual Studio Code's Remote - Containers extension.
+- **When to Use**: Use this sub-structkit when you need to define development container configurations for your project.
+
+#### `configs/editor-config`
+
+- **Description**: Provides a template for the `.editorconfig` file, which defines coding styles and formatting rules for different editors and IDEs.
+- **When to Use**: Use this sub-structkit when you need to define coding styles and formatting rules for your project.
+
+#### `configs/eslint`
+
+- **Description**: Provides a template for the `.eslintrc` file, which defines ESLint configurations for JavaScript projects.
+- **When to Use**: Use this sub-structkit when you need to define ESLint configurations for your JavaScript project.
+
+#### `configs/jshint`
+
+- **Description**: Provides a template for the `.jshintrc` file, which defines JSHint configurations for JavaScript projects.
+- **When to Use**: Use this sub-structkit when you need to define JSHint configurations for your JavaScript project.
+
+#### `configs/prettier`
+
+- **Description**: Provides a template for the `.prettierrc` file, which defines Prettier configurations for code formatting.
+- **When to Use**: Use this sub-structkit when you need to define Prettier configurations for your project.
+
+### Github
+
+#### `github/workflows/execute-tf-workflow`
+
+- **Description**: Provides a template for a GitHub Actions workflow that executes Terraform commands.
+- **When to Use**: Use this sub-structkit when you need to automate Terraform workflows using GitHub Actions. each terraform app should have a workflow that executes terraform commands.
+
+#### `github/workflows/pre-commit`
+
+- **Description**: Provides a template for a GitHub Actions workflow that runs pre-commit checks.
+- **When to Use**: Use this sub-structkit when you need to run pre-commit checks on your codebase using GitHub Actions.
+
+#### `github/workflows/labeler`
+
+- **Description**: Provides a template for a GitHub Actions workflow that labels issues and pull requests.
+- **When to Use**: Use this sub-structkit when you need to automatically label issues and pull requests based on certain criteria.
+
+#### `github/workflows/release-drafter`
+
+- **Description**: Provides a template for a GitHub Actions workflow that generates release notes using Release Drafter.
+- **When to Use**: Use this sub-structkit when you need to automatically generate release notes for your project using Release Drafter.
+
+#### `github/workflows/run-struct`
+
+- **Description**: Provides a template for a GitHub Actions workflow that runs the structkit CLI.
+- **When to Use**: Use this sub-structkit when you need to run the structkit CLI as part of your GitHub Actions workflows.
+
+#### `github/workflows/stale`
+
+- **Description**: Provides a template for a GitHub Actions workflow that closes stale issues and pull requests.
+- **When to Use**: Use this sub-structkit when you need to automatically close stale issues and pull requests in your repository.
+
+#### `github/templates`
+
+- **Description**: Provides templates for GitHub issue and pull request templates.
+- **When to Use**: Use this sub-structkit when you need to define issue and pull request templates for your GitHub repository.
+
+#### `github/prompts/generic`
+
+- **Description**: Provides a generic prompt for creating a new project structure.
+- **When to Use**: Use this sub-structkit when you need to create a new project structure using the structkit CLI.
+
+#### `github/prompts/react-form`
+
+- **Description**: Provides a prompt for creating a React form component.
+- **When to Use**: Use this sub-structkit when you need to create a React form component.
+
+#### `github/prompts/security-api`
+
+- **Description**: Provides a prompt for creating a security API.
+- **When to Use**: Use this sub-structkit when you need to create a security API.
+
+#### `github/prompts/struct`
+
+- **Description**: Provides a prompt for creating a new .struct.yaml file and workflow to run struct.
+- **When to Use**: Use this sub-structkit when you need to create a new .struct.yaml file and workflow to run struct.
+
+### Project
+
+#### `project/generic`
+
+- **Description**: Provides a generic project structure with directories for source code, documentation, and tests.
+- **When to Use**: Use this sub-structkit when you need to create a generic project structure for your application.
+
+#### `project/java`
+
+- **Description**: Provides a Java project structure with directories for source code, resources, and tests.
+- **When to Use**: Use this sub-structkit when you need to create a Java project structure for your application.
+
+#### `project/nodejs`
+
+- **Description**: Provides a Node.js project structure with directories for source code, tests, and configuration files.
+- **When to Use**: Use this sub-structkit when you need to create a Node.js project structure for your application.
+
+#### `project/rust`
+
+- **Description**: Provides a Rust project structure with directories for source code, tests, and configuration files.
+- **When to Use**: Use this sub-structkit when you need to create a Rust project structure for your application.
+
+#### `project/python`
+
+- **Description**: Provides a Python project structure with directories for source code, tests, and configuration files.
+- **When to Use**: Use this sub-structkit when you need to create a Python project structure for your application.
+
+#### `project/go`
+
+- **Description**: Provides a Go project structure with directories for source code, tests, and configuration files.
+- **When to Use**: Use this sub-structkit when you need to create a Go project structure for your application.
+
+#### `project/ruby`
+
+- **Description**: Provides a Ruby project structure with directories for source code, tests, and configuration files.
+- **When to Use**: Use this sub-structkit when you need to create a Ruby project structure for your application.
+
+### Terraform
+
+#### `terraform/modules/generic`
+
+- **Description**: Provides a generic Terraform module structure with directories for resources, variables, and outputs.
+- **When to Use**: Use this sub-structkit when you need to create a generic Terraform module for your infrastructure.
+
+#### `terraform/apps/generic`
+
+- **Description**: Provides a generic Terraform application structure with directories for modules, environments, and configurations.
+- **When to Use**: Use this sub-structkit when you need to create a generic Terraform application for your infrastructure.
+
+#### `terraform/apps/aws-accounts`
+
+- **Description**: Provides a Terraform application structure for managing AWS accounts.
+- **When to Use**: Use this sub-structkit when you need to manage AWS accounts using Terraform.
+
+#### `terraform/apps/github-organization`
+
+- **Description**: Provides a Terraform application structure for managing GitHub organizations.
+- **When to Use**: Use this sub-structkit when you need to manage GitHub organizations using Terraform.
+
+#### `terraform/apps/environments`
+
+- **Description**: Provides a Terraform application structure for managing environments.
+- **When to Use**: Use this sub-structkit when you need to manage environments using Terraform.
+
+#### `terraform/apps/init`
+
+- **Description**: Provides a Terraform application structure for initializing a new project.
+- **When to Use**: Use this sub-structkit when you need to initialize a new Terraform project.
+
+---
+
+Each of these sub-structs is designed to simplify the process of setting up specific project structures or configurations. Refer to the individual YAML files for more details on their usage and customization options.

structkit/contribs/ansible-playbook.yaml

@@ -0,0 +1,38 @@
+files:
+  - main.yml:
+      content: |
+        - name: Example Playbook
+          hosts: all
+          become: yes
+          roles:
+            - example-role
+  - vars.yml:
+      content: |
+        example_variable: "value"
+  - tasks/main.yml:
+      content: |
+        - name: Install packages
+          apt:
+            name: "{{ item }}"
+            state: present
+          with_items:
+            - git
+            - curl
+  - handlers/main.yml:
+      content: |
+        - name: Restart service
+          service:
+            name: example-service
+            state: restarted
+  - templates/README.md:
+      content: |
+        # Example Template
+        This template contains example configuration files.
+  - README.md:
+      content: |
+        # Playbook Name
+        This playbook installs necessary packages and configures services.
+        ## Usage
+        ```bash
+        ansible-playbook -i inventory main.yml
+        ```

structkit/contribs/chef-cookbook.yaml

@@ -0,0 +1,51 @@
+files:
+  - recipes/default.rb:
+      content: |
+        package 'nginx' do
+          action :install
+        end
+        service 'nginx' do
+          action [ :enable, :start ]
+        end
+  - attributes/default.rb:
+      content: |
+        default['nginx']['version'] = 'latest'
+  - templates/default/nginx.conf.erb:
+      content: |
+        user  nginx;
+        worker_processes  auto;
+        error_log  /var/log/nginx/error.log warn;
+        pid        /var/run/nginx.pid;
+        events {
+            worker_connections  1024;
+        }
+        http {
+            include       /etc/nginx/mime.types;
+            default_type  application/octet-stream;
+            sendfile        on;
+            keepalive_timeout  65;
+            server {
+                listen       80;
+                server_name  localhost;
+                location / {
+                    root   html;
+                    index  index.html index.htm;
+                }
+            }
+        }
+  - files/default/index.html:
+      content: |
+        <html>
+        <head>
+          <title>Welcome to nginx!</title>
+        </head>
+        <body>
+          <h1>Success! The nginx server is working!</h1>
+        </body>
+        </html>
+  - README.md:
+      content: |
+        # Cookbook Name
+        Chef cookbook for configuring NGINX.
+        ## Usage
+        Add the cookbook to your Chef server and include it in your run list.

structkit/contribs/ci-cd-pipelines.yaml

@@ -0,0 +1,67 @@
+files:
+  - .gitlab-ci.yml:
+      content: |
+        stages:
+          - build
+          - test
+          - deploy
+        build_job:
+          stage: build
+          script:
+            - echo "Building the project"
+        test_job:
+          stage: test
+          script:
+            - echo "Running tests"
+        deploy_job:
+          stage: deploy
+          script:
+            - echo "Deploying the project"
+  - Jenkinsfile:
+      content: |
+        pipeline {
+            agent any
+            stages {
+                stage('Build') {
+                    steps {
+                        echo 'Building the project'
+                    }
+                }
+                stage('Test') {
+                    steps {
+                        echo 'Running tests'
+                    }
+                }
+                stage('Deploy') {
+                    steps {
+                        echo 'Deploying the project'
+                    }
+                }
+            }
+        }
+  - .github/workflows/ci.yml:
+      content: |
+        name: CI
+        on: [push, pull_request]
+        jobs:
+          build:
+            runs-on: ubuntu-latest
+            steps:
+              - name: Checkout code
+                uses: actions/checkout@v2
+              - name: Build
+                run: echo "Building the project"
+              - name: Test
+                run: echo "Running tests"
+  - .github/workflows/cd.yml:
+      content: |
+        name: CD
+        on: [push]
+        jobs:
+          deploy:
+            runs-on: ubuntu-latest
+            steps:
+              - name: Checkout code
+                uses: actions/checkout@v2
+              - name: Deploy
+                run: echo "Deploying the project"