sensible-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4841010ea567e04f3f358f1f98b9e61aedb419c6f6857f5f2644bc0d9c5d58e3
+  data.tar.gz: 16b5ce3ead9edfd3ff17465f8cb4d5c9463ef5bf14e429e02ab8b70f249921c7
+SHA512:
+  metadata.gz: dd36abd65d68819f83f817aa4979bda0ad78aa4b173e42c1792500812ac99501d5d0aaccac02d3d84da2c636338769adc41fcba7453266dbbf1b36efc0763b42
+  data.tar.gz: 5b1e16c926d168f4498e440161c294587428562b1a8672e2bf7606f111219c32e12fd0c5719e96141530698ae9e8c4cd8d3554aca15c65aebf16a6dffa296f90

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.sensible/tasks/another.yml

@@ -0,0 +1,7 @@
+---
+name: Another test task
+description: This is a sample task, and this is its description
+install: |
+  echo "This is a multi line script"
+  echo "I should use a temp file to run"
+  notify-send "This is the post task that ran!"

data/.sensible/tasks/test.yml

@@ -0,0 +1,4 @@
+---
+name: This is a sample task in a seperate file
+description: This is a sample task, and this is its description
+install: notify-send "This is the pre task that ran!"

data/README.md

@@ -0,0 +1,210 @@
+# Sensible
+A small tool to manage projects.
+
+## NOTICE
+The tool is still in very early development, and it's not ready for production use.
+
+Everything is subject to change, and the tool is not stable.
+
+## Why?
+The reason I made this tool, is I work on a lot of project at work, and we are a very small team. We work on separate things for the same projects, like I work on the frontend, and the other guy on the database.
+He has his own tooling, and need a bunch of stuff installed and various settings set in files, to run the database. I have also my own tooling, and we often have to spend a lot of time helping with setting up our part of the project for each other so we can run them locally.
+
+So to make things easier, I created this tool to help us document and setup each part of the projects, and make sure we have everything required to run each part.
+
+It can also be used to document the setup process for a project, and make it easier for new developers to get started with the project. 
+
+It's inspired by the `flutter doctor` feature in Flutter.
+
+It's currently focused for usage in linux environments, but it should work on MacOS as well. It's not tested on Windows, but it should work with WSL. It uses zx by google to run the scripts, and it's only tested on linux.
+
+## Installing
+You can use the binary from the releases page, or you can install it with the RPM package from the same page
+
+```
+gem install sensible-ruby
+```
+
+# Docs
+
+## Sensible file
+The sensible file is a yaml file that defines the packages, requirements and tasks for the project. The sensible file should be in the root of the project and should be named `sensible.yml`. You can run the `sensible init` command to create a new sensible file.
+
+The `sensible.yml` should look like this:
+
+```yaml
+---
+preTasks:
+packages:
+requirements:
+postTasks:
+```
+This is the basic structure of the sensible file. You can add the packages, requirements, tasks, and postTasks to the file.
+
+**All properties are optional, and you can omit them if you don't need them.**
+
+### Packages
+The packages are the packages that should be installed. The packages should be defined in the `packages` section of the sensible file.
+
+The packages should be defined like this:
+
+```yaml
+packages:
+  - name: <package-name>
+    install: <install-command>
+    env:
+      - <environment 1>
+      - <environment 2>
+```  
+The package should be the name of the command the package provides. As an example, if you check if Nodejs is installed `node`, the package name should be `node`.
+It uses the [semver](https://www.npmjs.com/package/semver) npm package to check if the version is in the correct range.
+
+The env property is optional, and if it's not defined, the package will be installed in every environment
+
+The property `install` is the shell command that install the package.
+
+### Requirements
+The requirements section defines the requirements for the project, like if you need specific settings in a file, or a line in /etc/hosts. They work pretty much like tasks, but it's a way to document the requirements for the project, and structure the setup process.
+
+The requirement should be defined like this:
+```yaml
+# sensible.yml
+requirements:
+  - name: <requirement-name>
+    check: <shell script to check if the requirement is met>
+    install: <shell script to make the requirement met>
+    env:
+      - <environment 1>
+      - <environment 2>
+```
+The check and install script should be kept as short and simple as possible. If it gets too complex, it should be a task instead.
+
+#### Tasks
+Tasks are the files that define the tasks that should be run. The task files should be placed in the `.sensible/tasks` folder in the root of the project.
+The tasks should be defined like this:
+
+```yaml
+# .sensible/tasks/example.yml
+---
+name: Example task
+description: This is an example task, showing how to define a task
+showOutput: true | false # Default is false
+script: echo "This is an example task"
+```
+You can use | to make multiline scripts
+```yaml
+# .sensible/tasks/example.yml
+---
+name: Example task 2
+description: This is an example task, showing how to define a task
+script: |
+  echo "This is an example task"
+  echo "This is a multiline script"
+```
+The script part is pure bash script. You can use any bash command in the script.
+
+Tasks has the following properties:
+- name: The name of the task
+- description: A description of the task
+- showOutput: If the output of the task should be shown in the terminal. Default is false
+- script: The bash script that should be run
+- env: The list of environments the task should be run in. The default is `dev`, and if you omit this property, it will be run in every environment.
+
+## Commands
+
+```
+Usage: sensible [options] [command]
+
+A simple sensible tool for your projects
+
+Options:
+  --env <string>               Set the environment (default: "dev")
+  -f, --sensibleFile <string>    Path to the sensible file
+  -d, --sensibleFolder <string>  Path to the sensible folder (default: ".sensible")
+  -p, --prod                   Set to production mode (default: false)
+  -V, --version                output the version number
+  -h, --help                   display help for command
+
+Commands:
+  check [options]              Check the project for missing dependencies
+  install [options]            Install missing dependencies and requirements
+  task <task>                  Manage tasks
+  init [options]               Create a new sensible file
+  help [command]               display help for command`
+```
+
+### `sensible init`
+This command creates a new sensible file in the root of your project. It will create a file called `sensible.yml`.
+
+
+### `sensible check`
+This checks the project for missing dependencies. It will check if the packages are installed and if they are in the correct version range. It uses the bash command `command -v` to check if the packages are installed.
+To determine the version of the package, it uses the `<command> --version` and `<command> --V` command.
+
+### `sensible install`
+This command installs missing dependencies and requirements. It will install the packages that are missing and are in the correct version range.
+
+It will also run the tasks that are defined in the sensible file.
+The order of the tasks is important. The tasks will be run in the order they are defined in the sensible file.
+
+The total order of things are like this:
+
+- preTasks
+- packages
+- requirements
+- postTasks
+
+### `sensible task`
+This command manages the tasks that are defined in your project.
+
+```
+Usage: sensible task [command] <task>
+
+Manage tasks
+
+Arguments:
+  task                     Task to run
+
+Options:
+  -h, --help               display help for command
+
+Commands:
+  run [options] <task>     Run a task
+  list [options]           List available tasks
+  create [options] <task>  Create a new task
+```
+
+Tasks will be placed in the `.sensible/tasks` when created, and it looks for them in that folder.
+
+#### `sensible task run`
+This will run a single task. Very useful if your project has need to do a lot of things to run it.
+
+The last argument for the command is the name of the task you want to run.
+
+`sensible run task example`
+
+This will run the task `example` in the `.sensible/tasks` folder.
+
+Possible use cases for tasks:
+- Setting up a database
+- Running migrations
+- Running tests
+- Running a development server
+- Reinstall node dependencies
+- Clearing cache files
+
+#### `sensible task list`
+This simply lists the tasks that are available in the `.sensible/tasks` folder.
+
+
+## Environments
+The sensible tool supports multiple environments. The default environment is `dev`. You can set the environment with the `--env` flag. 
+
+This means you can have different requirements, packages, and tasks for different environments, and you can name them however you want.
+
+An example of a command that sets the environment to `prod`:
+
+```bash
+sensible check --env prod # Check the project for missing dependencies in the prod environment
+sensible install --env stage # Install missing dependencies and requirements in the staging environment
+```

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/sensible

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+SPEC = %(
+  @ A small tool to manage and deploy projects
+
+  Install and update systems much like ansible but using shell scripts. It uses
+  a sensible.yml configuration file to control the process
+
+  OPTIONS
+    -e,env,environment=ENV
+      Sets the environment (dev/prod/etc),
+
+    -f,file=FILE
+      Path to sensible configuration file
+
+    -d,dir,directory=DIR
+      Path to sensible directory. Default '.sensible'
+
+    -v,verbose
+      Verbose output
+
+  COMMANDS
+    check!
+      Check the project for missing dependencies
+
+    install!
+      Install missing dependencies and requirements
+    
+    task.list!
+      List tasks
+    
+    task.run! -- TASK
+      Run a single task
+
+    task.create! -- TASK
+      Create a task
+
+    init!
+      Create a new sensible configuration file
+)
+
+require_relative '../lib/sensible.rb'
+require 'shellopts'
+
+# Monkey patch where version_number is not fetched correctly in ruby 3.4.2
+module ShellOpts
+  class ShellOpts
+    def version_number
+      Sensible::VERSION
+    end
+  end
+end
+
+opts, args = ShellOpts::process(SPEC, ARGV)
+cmd = opts.subcommand!
+#cmd == :task! or args.expect(0) # Ensure no arguments except for task
+
+if opts.verbose
+  puts "Options"
+  puts "  env: #{opts.env}"
+  puts "  file: #{opts.file}"
+  puts "  dir: #{opts.dir}"
+  puts "  args: #{args}"
+  # puts "Command: #{cmd.to_s.sub(/!$/, "")}"
+end
+
+case opts.subcommand
+  when :init!
+    Sensible::Sensible.init(opts)
+  else
+    sensible = Sensible::Sensible.new("sensible.yml", opts, args)
+
+    case opts.subcommand
+      when :check!
+        sensible.check
+      when :install!
+        sensible.install
+      when :task!
+        case cmd.subcommand
+          when :list!; sensible.task_list
+          when :run!
+            arg = args.expect(1) # Expect a single argument to sensible task
+            sensible.task_run(arg)
+          when :create!
+            arg = args.expect(1) # Expect a single argument to sensible task
+            sensible.task_create(arg)
+        end
+    end
+end
+

data/lib/sensible/log.rb

@@ -0,0 +1,68 @@
+require 'tty-prompt'
+require 'tty-spinner'
+require 'pastel'
+
+module Sensible
+  $pastel = Pastel.new
+
+  class Logger 
+    def self.log(message, indent = 0, use_print: false)
+        puts message
+    end
+
+    def self.success(message, indent = 0, use_print: false)
+      spaceIndent = ""
+      indent.times { |i| spaceIndent << " " }
+
+      if use_print
+        print "#{spaceIndent}#{$pastel.green("✔")} #{message}"
+      else      
+        puts "#{spaceIndent}#{$pastel.green("✔")} #{message}"
+      end
+    end
+
+    def self.info(message, indent = 0, use_print: false)
+      spaceIndent = ""
+      indent.times { |i| spaceIndent << " " }
+ 
+      if use_print
+        print "#{spaceIndent}#{$pastel.blue("i")} #{message}"
+      else      
+        puts "#{spaceIndent}#{$pastel.blue("i")} #{message}"
+      end
+    end
+
+    def self.danger(message, indent = 0, use_print: false)
+      spaceIndent = ""
+      indent.times { |i| spaceIndent << " " }
+      
+      if use_print
+        print "#{spaceIndent}#{$pastel.red("✘")} #{message}"
+      else      
+        puts "#{spaceIndent}#{$pastel.red("✘")} #{message}"
+      end      
+    end
+
+    def self.error(message, indent = 0, use_print: false)
+      spaceIndent = ""
+      indent.times { |i| spaceIndent << " " }
+
+      full_message = "#{spaceIndent}#{$pastel.on_red.black(" ERROR ")} #{message}"
+      
+      if use_print
+        print full_message
+      else      
+        puts full_message
+      end      
+    end
+
+    def self.yes?(message, indent = 0)
+      prompt = TTY::Prompt.new
+
+      spaceIndent = ""
+      indent.times { |i| spaceIndent << " " }
+
+      prompt.yes?("#{spaceIndent}#{message}")
+    end
+  end
+end

data/lib/sensible/package.rb

@@ -0,0 +1,52 @@
+require_relative 'log'
+require 'tty-prompt'
+require 'pastel'
+
+module Sensible
+  class Package
+    attr_reader :sensible
+    attr_reader :name
+    attr_reader :check
+    attr_reader :install
+    attr_reader :env
+
+    def initialize(packageHash, sensible)
+      @name = packageHash['name']
+      @check = packageHash['check']
+      @install = packageHash['install']
+      @env = packageHash['env'] || []
+
+      @sensible = sensible
+    end
+
+
+    # Check if the package is installed
+    def do_check
+      if @check
+        result = `#{@check}`
+        return $?.success?
+      else 
+        # If check is not set, then infer that it's a system package
+        result = `rpm -q #{@name}`
+      
+        if result.include? 'is not installed'
+          return false
+        else 
+          return true
+        end
+      end
+                 
+    end
+    
+    # Install the package
+    def do_install
+      if @install 
+        system(@install, out: File::NULL)
+        return $?.success?        
+      else
+        system("sudo", "dnf", "install", "-y", @name, out: File::NULL, err: File::NULL)
+        return $?.success?
+      end
+    end   
+  end
+end

data/lib/sensible/parse.rb

@@ -0,0 +1,36 @@
+require_relative 'task'
+require_relative 'requirement'
+require_relative 'package'
+
+module Sensible
+  class Parse
+    
+    # Parse the package list from sensible.yml
+    def self.parse_sensible_packages(sensible_hash_list, sensible)
+      list = []
+      for pkg in sensible_hash_list
+        list.append(Package.new(pkg, sensible))
+      end
+      return list
+    end
+
+    # Parse the task list from sensible.yml
+    def self.parse_sensible_tasks(sensible_hash_list, sensible)
+      list = []
+      for task in sensible_hash_list
+        list.append(Task.new(tash, sensible))
+      end
+      return list
+    end
+
+    # Parse the requirement list from sensible.yml
+    def self.parse_sensible_requirements(sensible_hash_list, sensible)
+      list = []
+      for pkg in sensible_hash_list
+        list.append(Requirement.new(pkg, sensible))
+      end
+      return list
+    end
+
+  end
+end

data/lib/sensible/requirement.rb

@@ -0,0 +1,7 @@
+require_relative 'package'
+
+module Sensible
+  class Requirement < Package
+    # Pretty much the same as package right now
+  end
+end

data/lib/sensible/task.rb

@@ -0,0 +1,67 @@
+require_relative 'package'
+
+module Sensible
+  class Task < Package
+    attr_reader :file_name
+    attr_reader :description
+    attr_accessor :show_output
+
+    def initialize(taskHash, file_name, sensible)
+      super(taskHash, sensible)
+      @file_name = file_name
+      @description = taskHash['description']
+      @show_output = taskHash['showOutput']
+    end
+    
+    def do_check
+      do_verify()
+
+      # If check is not set, always run the task
+      if @check == nil
+        return false
+      end
+
+      # If there is no check, default to false, to force task to install every time
+      system(@check, out: File::NULL)
+      return $?.success?
+    end  
+
+    def do_install
+      # TODO: Handle the show output property!
+
+      if @install.include?("\n")
+        temp_path = "/tmp/sensible"
+        temp_file_name = "install.sh"
+        temp_file_path = "#{temp_path}/#{temp_file_name}"
+
+        # Make sure we have the tmp folder created
+        FileUtils.mkdir_p(temp_path)
+
+        File.open(temp_file_path, "w") do |f| 
+          f.puts "#!/usr/bin/env bash\n\n"
+          f.write(@install)
+        end
+
+        # Make it executable
+        File.chmod(0700, temp_file_path)
+
+        system("#{temp_file_path}", out: File::NULL)
+        return $?.success?  
+      else
+        system(@install, out: File::NULL)
+        return $?.success?        
+      end
+    end
+
+    def do_verify
+      if !@install
+        pastel = Pastel.new
+        Logger.error("This is not valid task, #{pastel.bold("install")} property is missing!")
+        exit(1)
+        return false
+      end
+
+      return true
+    end
+  end
+end

data/lib/sensible/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sensible
+  VERSION = "0.1.0"
+end

data/lib/sensible.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+require 'yaml'
+require_relative "sensible/version"
+require_relative "sensible/package"
+require_relative "sensible/log"
+require_relative "sensible/parse"
+
+module Sensible
+  class Error < StandardError; end
+
+  class Sensible
+    attr_reader :opts
+    attr_reader :args
+
+    attr_reader :preTasks
+    attr_reader :packages
+    attr_reader :requirements
+    attr_reader :postTasks
+    
+    attr_reader :sensible_folder
+    attr_reader :tasks_folder
+
+
+    def initialize(sensibleFileName, opts, args)
+      @opts = opts
+      @args = args
+
+      @sensible_folder = '.sensible'
+      @tasks_folder = 'tasks'
+
+      file_name = opts.file || sensibleFileName
+      unless File.exist?(file_name)
+          Logger.error("Required file not found: #{file_name}")
+          exit(1)
+      end
+
+      # Load the Sensile file
+      sensible_file_data = YAML.load_file(file_name)
+
+      # Parse packages
+      if sensible_file_data['packages'] 
+        @packages = Parse.parse_sensible_packages(sensible_file_data['packages'], self)
+      end
+
+      # Parse packages
+      if sensible_file_data['requirements'] 
+        @requirements = Parse.parse_sensible_requirements(sensible_file_data['requirements'], self)
+      end
+
+      if (sensible_file_data['preTasks'])
+        @preTasks = sensible_file_data['preTasks']
+      end
+
+      if (sensible_file_data['postTasks'])
+        @postTasks = sensible_file_data['postTasks']
+      end
+    end
+
+
+    # Run all the checks for packages and requirements
+    def check
+      Logger.log("Checking for installed packages...")
+      
+      for pkg in @packages
+        # Do an environment test
+        if @opts.env
+          # If package env is not define, we expect it should always be installed regardless of environment
+          # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
+          next if pkg.env.any? && !pkg.env.include?(@opts.env)
+        else
+          # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
+          next if pkg.env.any?
+        end
+
+        if pkg.do_check
+          Logger.success("#{pkg.name} is installed")
+        else
+          Logger.danger("#{pkg.name} was NOT installed")
+        end
+      end    
+      
+      if @requirements != nil
+        Logger.log("\nChecking if requirements are met...")
+
+        for requirement in @requirements
+          # Do an environment test
+          if @opts.env
+            # If package env is not define, we expect it should always be installed regardless of environment
+            # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
+            next if requirement.env.any? && !requirement.env.include?(@opts.env)
+          else
+            # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
+            next if pkg.env.any?
+          end
+
+          if requirement.do_check
+            Logger.success("#{requirement.name}")
+          else
+            Logger.danger("#{requirement.name}")
+          end
+        end
+      end
+    end
+
+    def install
+      # Prewarm sudo, to prevent asking too much
+      system('sudo -v')
+
+      # Run pre tasks
+      if @preTasks != nil
+        Logger.log("Running pre tasks...")
+
+        for task in @preTasks
+          task_run(task)
+        end
+        Logger.log("")
+      end
+      
+      # Install packages
+      if @packages != nil
+        Logger.log("Installing packages...")
+        for pkg in @packages
+          # Do an environment test
+          if @opts.env
+            # If package env is not defined, we expect it should always be installed regardless of environment
+            # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
+            next if pkg.env.any? && !pkg.env.include?(@opts.env)
+          else
+            # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
+            next if pkg.env.any?
+          end
+
+          if pkg.do_check
+            Logger.success("#{pkg.name} is installed")
+          else
+            Logger.info("Installing: #{pkg.name}\r", use_print: true)
+            if pkg.do_install
+              Logger.success("#{pkg.name} was installed")
+              $stdout.flush
+            else
+              Logger.danger("#{pkg.name} was not installed")
+              $stdout.flush
+            end
+          end
+        end  
+        Logger.log("")
+      end
+      
+      # Handle requirements
+      if @requirements != nil 
+        Logger.log("Handling requirements...")
+        for requirement in @requirements
+          # Do an environment test
+          if @opts.env
+            # If package env is not defined, we expect it should always be installed regardless of environment
+            # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
+            next if requirement.env.any? && !requirement.env.include?(@opts.env)
+          else
+            # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
+            next if requirement.env.any?
+          end
+
+          if requirement.do_check
+            Logger.success("#{requirement.name}")
+          else
+            Logger.info("Handling: #{pkg.name}\r", use_print: true)
+            if requirement.do_install
+              Logger.success("#{requirement.name}")
+              $stdout.flush
+            else
+              Logger.danger("#{requirement.name}")
+              $stdout.flush
+            end
+          end
+        end
+        Logger.log("")
+      end
+    
+      # Run post tasks
+      if @postTasks != nil
+        Logger.log("Running post tasks...")
+
+        for task in @postTasks
+          task_run(task)
+        end
+      end
+
+    end
+
+    def self.init(opts)
+      sensible_file_name = "sensible.yml"
+
+      if opts.file
+        if opts.file.end_with?(".yml")
+          sensible_file_name = opts.file
+        else
+          sensible_file_name = opts.file + ".yml"
+        end
+      end
+
+      if not File.exist?(sensible_file_name)
+        File.open(sensible_file_name, "w") do |f| 
+          f.write(<<~EOF)
+            ---
+            packages:
+            requirements:
+          EOF
+        end
+        Logger.success("Created #{sensible_file_name}!")
+      else 
+        Logger.error("Cannot create #{sensible_file_name}, it already exists!")
+      end
+    end
+
+    def task_run(task_name)
+      # Load and parse the task file
+      task_file_path = "#{@sensible_folder}/#{@tasks_folder}/#{task_name}.yml"
+      
+      # If task is not found, exit!
+      if not File.exist?(task_file_path)
+        pastel = Pastel.new
+        Logger.error("Task: #{pastel.bold(task_name)} does not exist!")
+        exit(1)
+      end
+
+      task = Task.new(YAML.load_file(task_file_path), "#{task_name}.yml", self)
+
+      pastel = Pastel.new
+      Logger.info("Running task: #{pastel.bold(task_name)}")
+      
+      # Check if we need to rerun the task
+      if !task.do_check
+        if !task.do_install
+          Logger.error("The tasked failed!")
+        else
+          Logger.success("The task ran succesfully!")
+        end
+      else
+        puts "Task check is already met"
+      end
+    end
+
+    def task_list
+      # Parse tasks
+      tasks_path = "#{@sensible_folder}/#{@tasks_folder}"
+      task_files = Dir.children(tasks_path)
+
+      tasks = []
+      for task_file in task_files
+        tasks << Task.new(YAML.load_file("#{tasks_path}/#{task_file}"), task_file, self)
+      end
+
+      puts "Here is available tasks inside #{@sensible_folder}/#{tasks_folder}" if @opts.verbose
+
+      pastel = Pastel.new
+      for task in tasks
+        Logger.log("#{pastel.blue.bold(task.file_name)}: #{task.name}")
+      end
+    end
+
+    def task_create(task_name)
+      tasks_path = "#{@sensible_folder}/#{@tasks_folder}"
+      task_file_path = "#{tasks_path}/#{task_name}.yml"
+      
+      # Make sure the task don't already exist
+      if File.exist?(task_file_path)
+        pastel = Pastel.new
+        Logger.error("Task: #{pastel.bold(task_name)} already exist!")
+        exit(1)
+      end
+      
+      # Create the task yaml file
+      File.open(task_file_path, "w") do |f| 
+        f.write(<<~EOF)
+          ---
+          name:
+          description:
+          install:
+        EOF
+      end
+
+      pastel = Pastel.new
+      Logger.success("Created the task: #{pastel.bold("#{task_name}.yml")}")  
+    end
+  end
+end

data/sensible.yml

@@ -0,0 +1,23 @@
+preTasks:
+  - test
+
+packages:
+  - name: httpd
+  - name: htop
+  - name: btop
+    env: 
+      - prod
+  - name: rvm
+    check: which rvm
+
+requirements:
+  - name: Test requirement
+    check: which node
+    install: echo "install"
+  
+  - name: Test requirement that fails
+    check: exit 1
+    install: exit 1
+  
+postTasks:
+  - another

data/sig/sensible.rbs

@@ -0,0 +1,4 @@
+module Sensible
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: sensible-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mikkel Jensen
+bindir: exe
+cert_chain: []
+date: 2025-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shellopts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-which
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-command
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small tool to manage projects, making shell scripts easier to manage,
+  and faster to setup projects!
+email:
+- dasmikko@gmail.com
+executables:
+- sensible
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".sensible/tasks/another.yml"
+- ".sensible/tasks/test.yml"
+- README.md
+- Rakefile
+- exe/sensible
+- lib/sensible.rb
+- lib/sensible/log.rb
+- lib/sensible/package.rb
+- lib/sensible/parse.rb
+- lib/sensible/requirement.rb
+- lib/sensible/task.rb
+- lib/sensible/version.rb
+- sensible.yml
+- sig/sensible.rbs
+homepage: https://github.com/dasmikko/sensible-ruby
+licenses: []
+metadata:
+  homepage_uri: https://github.com/dasmikko/sensible-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: A small tool to manage projects.
+test_files: []