bard 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a48fc76ba8d93a7cbf4527db8645112863b1f21fd76616b260e43d70df8cf789
-  data.tar.gz: a8ccdfeb4872d4659f27018637395e111286af2c75cc7b4b31fde32744f4919a
+  metadata.gz: 6e59f0686a010077d3980ceea61597d7c3bac7bd60358110c0e180990df10afc
+  data.tar.gz: 7e4ef9ac960e6fb28e7e465357e9edaa806bad6b537f580c3eb86ed1ef271e50
 SHA512:
-  metadata.gz: 6be5034adb2ce0c03540eef11b46bd00aba88ce4f333fd31d0fb914ee2568c6d355942efd3380b066c909c891c5b9d3fb8d4d3cf5f4cd2854e9d2f87d7f04ba4
-  data.tar.gz: b410e47c51b5c7d968cf3a633da99d54ef3908c58b517c36ad85389bc7f533e69efc7e35ebb96eb70cb86181e5c836b25c3393f30e4d04dd9518f036247d0ba8
+  metadata.gz: 2f1d8d605e8331cc5375170e1206eb3d5a4c665603f9556ce2d2823ee240b867b667695f38084dafa732dce1dd44a58a890d57b48365cdb09197d308321edb16
+  data.tar.gz: 56381e180c1d9a65d9f990023bbd23867793a82b77007de941fd3e70d674cd3cd6c5df237c7be61382030ba03711513276411f9c2a77e28a662d159e1781808f

data/README.md

@@ -1,497 +1,17 @@
-# Bard
+# bard
 
-A modular deployment tool for Ruby applications that makes deployment simple and extensible.
+The config core of the bard toolchain: the `bard.rb` DSL parser plus the target and SSH primitives everything else is built upon.
 
-## Quick Start
+## What's here
 
-```ruby
-# bard.rb
-target :production do
-  ssh "deploy@example.com:22"
-end
-```
-
-```bash
-bard deploy
-```
-
-## Features
-
-- **Modular Capabilities**: Enable only the features you need
-- **Pluggable Strategies**: SSH, GitHub Pages, or create your own
-- **Default Targets**: Pre-configured for common Bot and Rose workflows
-- **Git Integration**: Built-in branch management and safety checks
-- **CI Integration**: Auto-detects GitHub Actions or Jenkins
-- **Data Syncing**: Copy databases and assets between targets
-
-## Installation
-
-Add to your Gemfile:
-
-```ruby
-gem 'bard'
-```
-
-Or install globally:
-
-```bash
-gem install bard
-```
-
-## Core Concepts
-
-### Targets
-
-A **target** is a deployment destination. Targets can be servers, serverless environments, static hosting, or anything else you can deploy to.
-
-```ruby
-target :production do
-  ssh "deploy@example.com:22", path: "app"
-end
-```
-
-### Capabilities
-
-Capabilities are features enabled on targets. Common capabilities include:
-
-- **SSH**: Remote command execution and file transfer
-- **Ping**: Health check URLs
-- **Data**: Database and file syncing
-- **Backup**: Automatic backups during deployment
-
-### Deployment Strategies
-
-Strategies determine how code gets deployed. Built-in strategies:
-
-- **SSH**: Deploy via git pull on remote server
-- **GitHub Pages**: Deploy static site to gh-pages branch
-- **Custom**: Define your own (Jets, Docker, Kubernetes, etc.)
-
-## Configuration
-
-Create a `bard.rb` file in your project root:
-
-```ruby
-# Simple SSH deployment
-target :production do
-  ssh "deploy@example.com:22",
-    path: "app",
-    gateway: "bastion@example.com:22"
-end
-
-# GitHub Pages static site
-target :production do
-  github_pages "https://example.com"
-end
-
-# Custom strategy (Jets serverless)
-require_relative 'lib/jets_deploy_strategy'
-
-target :production do
-  jets "https://api.example.com", run_tests: true
-end
-```
-
-## Default Targets
-
-Bard ships with default targets for Bot and Rose workflows. Override any in your `bard.rb`:
-
-- **:local** - Local development (no SSH)
-- **:ci** - Jenkins CI at staging.botandrose.com
-- **:staging** - Staging server at staging.botandrose.com
-- **:gubs** - Bot and Rose cloud server
-
-```ruby
-# Override default staging to use Jets
-target :staging do
-  jets "https://staging-api.example.com"
-end
-
-# Keep :ci, :gubs, :local as defaults
-```
-
-## Commands
-
-### Deployment
-
-```bash
-# Deploy current branch to production (default)
-bard deploy
-
-# Deploy a specific branch to production
-bard deploy feature-branch
-
-# Deploy to a different target
-bard deploy --target=staging
-bard deploy feature-branch --target=staging
-
-# Deploy feature branch to staging (no merge)
-bard stage feature-branch
-
-# Skip CI checks
-bard deploy --skip-ci
-```
-
-### Data Management
-
-```bash
-# Copy database and assets from production to local
-bard data --from=production --to=local
-
-# Copy staging data to local
-bard data --from=staging --to=local
-
-# Configure additional paths to sync
-# bard.rb:
-data "public/uploads", "public/system"
-```
-
-### SSH Commands
-
-```bash
-# SSH into a target
-bard ssh production
-
-# Run a command on a target
-bard run production "bundle exec rails console"
-```
-
-### CI
-
-```bash
-# Run CI for current branch
-bard ci
-
-# Run tests locally
-bard ci --local-ci
-
-# Check CI status
-bard ci --status
-```
-
-### Utilities
-
-```bash
-# Open target URL in browser
-bard open production
-
-# Ping target to check health
-bard ping production
-
-# Show uncommitted changes
-bard hurt
-
-# Open changed files in vim
-bard vim
-```
-
-### Provisioning
-
-```bash
-# Full server provisioning
-bard provision deploy@new-server.com:22
-
-# Configure nginx for current app
-bard setup
-```
-
-## SSH Capability
-
-Enable SSH to run commands and transfer files:
-
-```ruby
-target :production do
-  ssh "user@host:port",
-    path: "deploy/path",
-    gateway: "bastion@host:port",
-    ssh_key: "/path/to/key",
-    env: "RAILS_ENV=production"
-end
-```
-
-This provides:
-- `target.run!(command)` - Execute remote command (raises on error)
-- `target.run(command)` - Execute remote command (silent on error)
-- `target.exec!(command)` - Replace process with remote command
-- `target.copy_file(path, to: target)` - Copy file to another target
-- `target.copy_dir(path, to: target)` - Rsync directory to another target
-
-## Deployment Strategies
-
-### SSH Strategy
-
-Deploy by running git pull on remote server:
-
-```ruby
-target :production do
-  ssh "deploy@example.com:22"
-end
-```
-
-Deployment runs: `git pull origin master && bin/setup`
-
-### GitHub Pages Strategy
-
-Deploy static site to GitHub Pages:
-
-```ruby
-target :production do
-  github_pages "https://example.com"
-end
-```
-
-Deployment:
-1. Starts Rails server locally
-2. Mirrors site with wget
-3. Creates orphan commit with static assets
-4. Force-pushes to `gh-pages` branch
-
-### Custom Strategies
-
-Create your own deployment strategy:
-
-```ruby
-# lib/jets_deploy_strategy.rb
-module Bard
-  class DeployStrategy
-    class Jets < DeployStrategy
-      def deploy
-        target_name = target.key.to_s
-        options = target.strategy_options(:jets)
-
-        run! "rake vips:build:#{target_name}" unless options[:skip_build]
-        run! "bundle exec rspec" if should_run_tests?(target_name, options)
-        run! "jets deploy #{options[:env] || target_name}"
-      end
-
-      private
-
-      def should_run_tests?(target_name, options)
-        return options[:run_tests] if options.key?(:run_tests)
-        target_name == "production"
-      end
-    end
-  end
-end
-```
-
-Use it in your `bard.rb`:
-
-```ruby
-require_relative 'lib/jets_deploy_strategy'
-
-target :production do
-  jets "https://api.example.com", run_tests: true
-end
-
-target :staging do
-  jets "https://staging-api.example.com", skip_build: true
-end
-```
-
-Strategies auto-register via Ruby's `inherited` hook - no manual registration needed!
-
-## CI Configuration
-
-Bard auto-detects your CI system:
-- Finds `.github/workflows/ci.yml` → GitHub Actions
-- Otherwise → Jenkins (legacy)
-
-Override via DSL:
-
-```ruby
-# Force specific CI system
-ci :github_actions
-ci :jenkins
-ci :local
-
-# Disable CI
-ci false
-```
-
-## Ping Configuration
-
-Configure health check URLs:
-
-```ruby
-target :production do
-  ssh "deploy@example.com:22"
-  ping "https://example.com", "/health", "/status"
-end
-```
-
-Auto-configured by deployment strategies:
-
-```ruby
-# Ping URL automatically set from Jets URL
-target :production do
-  jets "https://api.example.com"
-end
-```
-
-## Data Syncing
-
-Database syncing is enabled by default when SSH is configured. Add file paths to sync:
-
-```ruby
-# Global configuration
-data "public/uploads", "public/system"
-
-target :production do
-  ssh "deploy@example.com:22"
-end
-```
-
-Then sync:
-
-```bash
-bard data --from=production --to=local
-```
-
-This:
-1. Runs `bin/rake db:dump` on source
-2. Copies `db/data.sql.gz` via SCP
-3. Runs `bin/rake db:load` on destination
-4. Rsyncs configured data paths
-
-## Backup Configuration
-
-Control whether backups are created during deployment:
-
-```ruby
-# Enable backups (default for SSH deployments)
-backup true
-
-# Disable backups (typical for serverless/static)
-backup false
-```
-
-## Example Configurations
-
-### Traditional Rails App
-
-```ruby
-target :staging do
-  ssh "deploy@staging.example.com:22"
-end
-
-target :production do
-  ssh "deploy@production.example.com:22"
-end
-
-data "public/uploads"
-backup true
-```
-
-### Serverless API (Jets)
-
-```ruby
-require_relative 'lib/jets_deploy_strategy'
-
-target :staging do
-  jets "https://staging-api.example.com"
-end
-
-target :production do
-  jets "https://api.example.com", run_tests: true
-end
-
-backup false
-```
-
-### Hybrid (Jets + SSH for debugging)
-
-```ruby
-require_relative 'lib/jets_deploy_strategy'
-
-target :staging do
-  jets "https://staging-api.example.com"
-  ssh "deploy@bastion.example.com:22"  # Enables SSH commands
-end
-
-target :production do
-  jets "https://api.example.com"
-  # No SSH in production
-end
-
-backup false
-```
-
-### Static Site
-
-```ruby
-target :production do
-  github_pages "https://example.com"
-end
-
-backup false
-```
-
-### Override Default Targets
-
-```ruby
-# Override default staging to use Jets
-target :staging do
-  jets "https://staging-api.example.com"
-end
-
-# Keep :ci, :gubs, :local targets as defaults
-```
-
-## Migration from v1.x
-
-See [MIGRATION_GUIDE.md](MIGRATION_GUIDE.md) for detailed migration instructions.
-
-Key changes in v2.0:
-- `server` renamed to `target`
-- SSH configuration uses hash options
-- Strategy-first configuration
-- Capability-based commands
-
-## Architecture
-
-Bard follows a modular, capability-based architecture:
-
-- **Core**: Minimal git workflow and configuration
-- **Capabilities**: Features enabled via DSL methods
-- **Strategies**: Pluggable deployment strategies with auto-registration
-- **Subsystems**: Independent and composable
-
-See [ARCHITECTURE.md](ARCHITECTURE.md) for detailed architecture documentation.
-
-## Custom Strategy Guide
-
-See [CUSTOM_STRATEGIES.md](CUSTOM_STRATEGIES.md) for a step-by-step guide to creating custom deployment strategies.
-
-## Plugin Development
-
-See [PLUGINS.md](PLUGINS.md) for a guide to creating plugins.
+- `Bard::Config` — parses `bard.rb`
+- `Bard::Target` / `Bard::SSHServer` — deployment targets and connection details
+- `Bard::Command` — SSH command execution
+- the `ssh` / `ping` / `url` / `data` / `github_pages` / `ci` DSL declarations
 
 ## Development
 
 ```bash
-# Clone repository
-git clone https://github.com/botandrose/bard.git
-cd bard
-
-# Install dependencies
 bundle install
-
-# Run tests
 bundle exec rspec
-
-# Run bard from source
-bundle exec bin/bard
 ```
-
-## License
-
-MIT License. Copyright (c) 2018 Micah Geisel. See LICENSE for details.
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request

data/Rakefile

@@ -1,9 +1,6 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
-require "cucumber/rake/task"
 
 RSpec::Core::RakeTask.new(:spec)
-Cucumber::Rake::Task.new(:cucumber)
-
-task :default => [:spec, :cucumber]
 
+task :default => [:spec]

data/bard.gemspec

@@ -8,25 +8,16 @@ Gem::Specification.new do |spec|
   spec.version       = Bard::VERSION
   spec.authors       = ["Micah Geisel"]
   spec.email         = ["micah@botandrose.com"]
-  spec.summary       = "CLI to automate common development tasks."
+  spec.summary       = "Config core for bard."
   spec.homepage      = "http://github.com/botandrose/bard"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = ["bard"]
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files    = spec.files.grep(%r{^(test|spec)/})
   spec.required_ruby_version = ">= 3.3"
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "thor", ">= 0.19.0"
-  spec.add_dependency "rvm"
-  spec.add_dependency "rbnacl"
-  spec.add_dependency "base64"
-
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "debug"
-  spec.add_development_dependency "cucumber"
-  spec.add_development_dependency "testcontainers"
-  spec.add_development_dependency "ostruct"
 end

data/lib/bard/config.rb

@@ -4,6 +4,11 @@ require "bard/plugins/ping/target_methods"
 
 module Bard
   class Config
+    class << self
+      attr_accessor :default_targets
+      attr_accessor :strict
+    end
+
     def self.current
       new(detect_project_name, path: "bard.rb")
     end
@@ -50,30 +55,27 @@ module Bard
       @targets[key.to_sym]
     end
 
-    private
-
-    def load_defaults
-      target :local
-
-      target :gubs do
-        ssh "botandrose@cloud.hackett.world:22022",
-          path: "Sites/#{config.project_name}"
-        url false
+    # A bard.rb may use DSL contributed by plugins. When the owning plugin is loaded it defines
+    # a real method that wins over this; otherwise we tolerate the declaration as a plain
+    # attribute so the file still parses — notably server-side, where bard-cli is absent.
+    def method_missing(name, *args, &block)
+      return super if self.class.strict
+      if args.empty? && block.nil?
+        (@attributes ||= {})[name]
+      else
+        (@attributes ||= {})[name] = args.length == 1 ? args.first : args
       end
+    end
 
-      target :ci do
-        ssh "jenkins@staging.botandrose.com:22022",
-          path: "jobs/#{config.project_name}/workspace"
-        url false
-      end
+    def respond_to_missing?(name, include_private = false)
+      !self.class.strict || super
+    end
 
-      staging_defaults = proc do
-        ssh "www@staging.botandrose.com:22022"
-        url "#{config.project_name}.botandrose.com"
-      end
+    private
 
-      target :staging, &staging_defaults
-      target :production, &staging_defaults
+    def load_defaults
+      target :local
+      Bard::Config.default_targets&.call(self)
     end
   end
 end

data/lib/bard/plugins/ping/target_methods.rb

@@ -1,6 +1,5 @@
 require "bard/target"
 require "bard/plugins/url/target_methods"
-require "bard/plugins/ping/check"
 
 class Bard::Target
   def ping(*urls)
@@ -12,12 +11,4 @@ class Bard::Target
       @ping_urls = urls.flatten.map { |u| normalize_url(u) }
     end
   end
-
-  def ping!
-    require_capability!(:url)
-    failed_urls = Bard::Ping.call(self)
-    if failed_urls.any?
-      raise "Ping failed for: #{failed_urls.join(", ")}"
-    end
-  end
 end

data/lib/bard/plugins/ssh/connection.rb

@@ -1,8 +1,8 @@
 require "uri"
-require "shellwords"
 require "bard/plugins/ssh/server"
-require "bard/command"
 
+# Data-only SSH mixin: enough for the parser to hold a target's connection details and
+# derive its url. The command-running methods (run!/ssh_command) live in bard-cli.
 module Bard
   module SSH
     def server
@@ -38,38 +38,5 @@ module Bard
       str += "/#{file_path}" if file_path
       str
     end
-
-    def run!(command, home: false, verbose: false, quiet: false, capture: false)
-      result = Command.run!(ssh_command(command, home:), verbose:, quiet:)
-      result if capture
-    end
-
-    def run(command, home: false, verbose: false, quiet: false)
-      Command.run(ssh_command(command, home:), verbose:, quiet:)
-    end
-
-    def exec!(command, home: false)
-      Command.exec!(ssh_command(command, home:))
-    end
-
-    private
-
-    def ssh_command(command, home: false)
-      cmd = command
-      cmd = "#{env} #{command}" if env
-
-      unless home
-        cmd = "cd #{path} && #{cmd}" if path
-      end
-
-      ssh_opts = ["-tt", "-o StrictHostKeyChecking=no", "-o UserKnownHostsFile=/dev/null", "-o LogLevel=ERROR"]
-      ssh_opts << "-i #{ssh_key}" if ssh_key
-      ssh_opts << "-p #{server.port}" if server.port && server.port != "22"
-      ssh_opts << "-o ProxyJump=#{gateway}" if gateway
-
-      ssh_target = "#{server.user}@#{server.host}"
-
-      "ssh #{ssh_opts.join(" ")} #{ssh_target} #{Shellwords.shellescape(cmd)}"
-    end
   end
 end

data/lib/bard/target.rb

@@ -1,5 +1,3 @@
-require "bard/command"
-
 module Bard
   class Target
     attr_reader :key, :config
@@ -30,19 +28,6 @@ module Bard
       @path || config.project_name
     end
 
-    def run!(command, home: false, verbose: false, quiet: false, capture: false)
-      result = Command.run!(command, verbose:, quiet:)
-      result if capture
-    end
-
-    def run(command, home: false, verbose: false, quiet: false)
-      Command.run(command, verbose:, quiet:)
-    end
-
-    def exec!(command, home: false)
-      Command.exec!(command)
-    end
-
     # Utility methods
     def to_s
       key.to_s