brainiac 0.0.28 → 0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: add3489f7ad183254936da1957e45221696ba277bc1119fd243cdde74c8114a8
-  data.tar.gz: 9fbc0a541c50978c549327528f4f64383735b386dd6688a9d38dae4353a04542
+  metadata.gz: 37f135fffb0c94919fa376fee96e12053af77062f93dadc520cce7285ee86e78
+  data.tar.gz: 553b10319590bde4fee8f89cf227059fec83d750d6ad7188d56aa5243a6cf169
 SHA512:
-  metadata.gz: 063130f40cb32c62a13e3fb5cf1c036d88e17f25e76243c3724f56e49776ffbaed5f025efc8a03b6792da24917d615665f5169147dfa3e28ed4ac9da5c63b1c7
-  data.tar.gz: a57864221e958f731ce29d77a9a2322eda834f4efd63bd83109dd326bcafbe749592a47fe29b1bc76ada0e51dc74380f76079802c3881b9465e66d2aea4cc653
+  metadata.gz: e04d26de1e9010e175b69032358e400223af29ffabde834e48b206d6cff58340fe1082262b36843fe6995aff752df2ed053793a78f416cc47d1dd4b47b881a99
+  data.tar.gz: fe32e3768064d1728a2b28d40aef900c1afb454d04e192b67a9e4f631bf117a147ebef547898709ead380b286336dee64da8a40b62cf6f10b7a327ca1bb3d505

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.28)
+    brainiac (0.0.29)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.28)
+  brainiac (0.0.29)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/lib/brainiac/handlers/shared/belt.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+# Belt application detection and environment management utilities.
+#
+# Belt is a Ruby framework for building serverless applications on AWS Lambda.
+# Projects using Belt have infrastructure defined in `config/routes.rb` or the
+# legacy `infrastructure/routes.tf.rb` path.
+#
+# This module provides detection and ephemeral environment helpers that plugins
+# (brainiac-fizzy, brainiac-github, brainiac-basecamp) can use.
+
+# Module containing Belt-related helpers accessible from Sinatra routes.
+module BeltHelpers
+  # Detect if a directory is a Belt application by checking for routes file.
+  #
+  # Belt apps are detected by the presence of any of these files:
+  #   - config/routes.rb (current)
+  #   - config/routes.tf.rb (legacy)
+  #   - infrastructure/routes.tf.rb (legacy)
+  #
+  # @param path [String] Path to check (repo root or worktree)
+  # @return [Boolean] True if the path contains a Belt application
+  def belt_app?(path)
+    return false unless path && File.directory?(path)
+
+    candidates = [
+      File.join(path, "config/routes.rb"),
+      File.join(path, "config/routes.tf.rb"),
+      File.join(path, "infrastructure/routes.tf.rb")
+    ]
+    candidates.any? { |f| File.exist?(f) }
+  end
+
+  # Check if a Belt app routes file exists and contains actual route definitions.
+  # This is a stricter check than belt_app? — it verifies the file has Belt routes,
+  # not just a Rails routes.rb file (which wouldn't have Belt-style route definitions).
+  #
+  # @param path [String] Path to check
+  # @return [Boolean] True if the path contains a Belt routes file with Belt syntax
+  def belt_routes_file?(path)
+    routes_file = belt_routes_path(path)
+    return false unless routes_file && File.exist?(routes_file)
+
+    # Check for Belt-specific syntax (e.g., `app.get`, `api`, `resources`, etc.)
+    content = File.read(routes_file, 4096) # Read first 4KB
+    content.match?(/\bapp\.(get|post|put|patch|delete)\b/) ||
+      content.match?(/\bapi\s+do\b/) ||
+      content.match?(/\bresources?\s+:/) ||
+      content.match?(/\bBelt\.routes\b/)
+  rescue StandardError
+    false
+  end
+
+  # Get the path to the Belt routes file (checking all possible locations).
+  #
+  # @param path [String] Path to check
+  # @return [String, nil] Path to routes file or nil
+  def belt_routes_path(path)
+    return nil unless path && File.directory?(path)
+
+    candidates = [
+      File.join(path, "config/routes.rb"),
+      File.join(path, "config/routes.tf.rb"),
+      File.join(path, "infrastructure/routes.tf.rb")
+    ]
+    candidates.find { |f| File.exist?(f) }
+  end
+end
+
+# Configuration for Belt ephemeral environments.
+# Stored in ~/.brainiac/basecamp.json under the "deploy" key.
+module BeltConfig
+  BRAINIAC_DIR = ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
+  BASECAMP_CONFIG_FILE = File.join(BRAINIAC_DIR, "basecamp.json")
+
+  class << self
+    # Load the basecamp config, caching for performance.
+    # @return [Hash]
+    def load_config
+      return {} unless File.exist?(BASECAMP_CONFIG_FILE)
+
+      JSON.parse(File.read(BASECAMP_CONFIG_FILE))
+    rescue JSON::ParserError => e
+      LOG.error "[Belt] Failed to parse basecamp.json: #{e.message}" if defined?(LOG)
+      {}
+    end
+
+    # Get the parent environment for a project (used as base for ephemeral envs).
+    # This is where `belt g environment <name> <parent>` copies settings from.
+    #
+    # @param project_key [String] Brainiac project key
+    # @return [String, nil] Parent environment name (e.g., "dev02", "dev") or nil
+    def parent_env_for(project_key)
+      config = load_config
+      config.dig("deploy", "project_envs", project_key)
+    end
+
+    # Check if ephemeral deploys are enabled globally.
+    # @return [Boolean]
+    def ephemeral_deploys_enabled?
+      config = load_config
+      # Default to true if deploy section exists but enabled isn't specified
+      deploy_config = config["deploy"] || {}
+      deploy_config.fetch("ephemeral_enabled", true)
+    end
+
+    # Track an ephemeral environment in deployment state.
+    # @param env_name [String] Environment name (e.g., "fizzy-123")
+    # @param metadata [Hash] Metadata about the ephemeral env
+    def track_ephemeral_env(env_name, metadata = {})
+      state_file = File.join(BRAINIAC_DIR, "ephemeral_envs.json")
+      state = File.exist?(state_file) ? JSON.parse(File.read(state_file)) : {}
+
+      state[env_name] = {
+        "created_at" => Time.now.iso8601,
+        "status" => "active"
+      }.merge(metadata)
+
+      File.write(state_file, JSON.pretty_generate(state))
+    rescue StandardError => e
+      LOG.error "[Belt] Failed to track ephemeral env: #{e.message}" if defined?(LOG)
+    end
+
+    # Check if an environment is ephemeral.
+    # @param env_name [String] Environment name
+    # @return [Boolean]
+    def ephemeral_env?(env_name)
+      state_file = File.join(BRAINIAC_DIR, "ephemeral_envs.json")
+      return false unless File.exist?(state_file)
+
+      state = JSON.parse(File.read(state_file))
+      state.key?(env_name) && state[env_name]["status"] == "active"
+    rescue StandardError
+      false
+    end
+
+    # Get ephemeral environment metadata.
+    # @param env_name [String] Environment name
+    # @return [Hash, nil]
+    def ephemeral_env_info(env_name)
+      state_file = File.join(BRAINIAC_DIR, "ephemeral_envs.json")
+      return nil unless File.exist?(state_file)
+
+      state = JSON.parse(File.read(state_file))
+      state[env_name]
+    rescue StandardError
+      nil
+    end
+
+    # Mark an ephemeral environment as destroyed.
+    # @param env_name [String] Environment name
+    def mark_ephemeral_destroyed(env_name)
+      state_file = File.join(BRAINIAC_DIR, "ephemeral_envs.json")
+      return unless File.exist?(state_file)
+
+      state = JSON.parse(File.read(state_file))
+      return unless state[env_name]
+
+      state[env_name]["status"] = "destroyed"
+      state[env_name]["destroyed_at"] = Time.now.iso8601
+
+      File.write(state_file, JSON.pretty_generate(state))
+    rescue StandardError => e
+      LOG.error "[Belt] Failed to mark ephemeral env destroyed: #{e.message}" if defined?(LOG)
+    end
+
+    # Find ephemeral environment by card number.
+    # @param card_number [Integer, String] Fizzy card number
+    # @return [String, nil] Environment name or nil
+    def ephemeral_env_for_card(card_number)
+      "fizzy-#{card_number}"
+    end
+
+    # Find ephemeral environment by epic number.
+    # @param epic_number [Integer, String] Epic number
+    # @return [String, nil] Environment name or nil
+    def ephemeral_env_for_epic(epic_number)
+      "epic-#{epic_number}"
+    end
+  end
+end
+
+# Belt environment operations (create, deploy, destroy).
+# These wrap the `belt` CLI commands for ephemeral environment management.
+module BeltEnvironment
+  class << self
+    include BeltHelpers
+
+    # Check whether an environment is configured in a worktree.
+    # `belt g environment` writes infrastructure/<env_name>/; that directory
+    # is the source of truth, not the ephemeral_envs.json tracking file.
+    #
+    # @param worktree [String] Path to the worktree
+    # @param env_name [String] Environment name (e.g. "fizzy-1299")
+    # @return [Boolean]
+    def environment_configured?(worktree:, env_name:)
+      return false unless worktree && env_name && File.directory?(worktree)
+
+      File.directory?(File.join(worktree, "infrastructure", env_name.to_s))
+    end
+
+    # Create an ephemeral environment from a parent environment.
+    #
+    # @param worktree [String] Path to the worktree
+    # @param env_name [String] Name for the ephemeral environment
+    # @param parent_env [String] Parent environment to copy from
+    # @return [Boolean] True on success
+    def create_environment(worktree:, env_name:, parent_env:)
+      return false unless belt_app?(worktree)
+
+      LOG.info "[Belt] Creating ephemeral environment '#{env_name}' from parent '#{parent_env}'"
+
+      _, stderr, status = Open3.capture3("belt", "g", "environment", env_name, parent_env, chdir: worktree)
+
+      if status.success?
+        LOG.info "[Belt] Successfully created environment '#{env_name}'"
+        true
+      else
+        LOG.error "[Belt] Failed to create environment '#{env_name}': #{stderr.strip}"
+        false
+      end
+    rescue StandardError => e
+      LOG.error "[Belt] Error creating environment: #{e.message}"
+      false
+    end
+
+    # Deploy to an environment.
+    #
+    # Always non-interactive: `belt deploy` prompts "Apply these changes? [y/N]"
+    # unless `--auto` is passed. Open3.capture3 provides empty stdin, so without
+    # `--auto` belt prints "Cancelled." and still exits 0 — a silent no-op.
+    # Frontend-only uses `belt deploy frontend <env>` (subcommand first).
+    #
+    # @param worktree [String] Path to the worktree
+    # @param env_name [String] Environment name
+    # @param frontend_only [Boolean] If true, only deploy frontend
+    # @return [Boolean] True on success
+    def deploy(worktree:, env_name:, frontend_only: false, capture3: nil)
+      return false unless belt_app?(worktree)
+
+      cmd = deploy_command(env_name, frontend_only: frontend_only)
+
+      LOG.info "[Belt] Deploying to '#{env_name}'#{" (frontend only)" if frontend_only}"
+      LOG.info "[Belt] Running: #{cmd.join(" ")} (in #{worktree})"
+
+      runner = capture3 || Open3.method(:capture3)
+      stdout, stderr, status = runner.call(*cmd, chdir: worktree)
+      log_cli_tail(stdout, stderr)
+
+      if deploy_cancelled?(stdout, stderr)
+        LOG.error "[Belt] Deploy to '#{env_name}' cancelled — non-interactive belt deploy needs --auto"
+        return false
+      end
+
+      if status.success?
+        LOG.info "[Belt] Successfully deployed to '#{env_name}'"
+        true
+      else
+        LOG.error "[Belt] Failed to deploy to '#{env_name}': #{stderr.strip}"
+        false
+      end
+    rescue StandardError => e
+      LOG.error "[Belt] Error deploying: #{e.message}"
+      false
+    end
+
+    # argv for `belt deploy`. Extracted so tests can assert the command without
+    # stubbing Open3 for every call site.
+    def deploy_command(env_name, frontend_only: false)
+      if frontend_only
+        ["belt", "deploy", "frontend", env_name]
+      else
+        ["belt", "deploy", env_name, "--auto"]
+      end
+    end
+
+    # Destroy an ephemeral environment.
+    #
+    # @param worktree [String] Path to the worktree (infrastructure lives here)
+    # @param env_name [String] Environment name
+    # @return [Boolean] True on success
+    def destroy_environment(worktree:, env_name:)
+      return false unless belt_app?(worktree)
+
+      LOG.info "[Belt] Destroying ephemeral environment '#{env_name}'"
+
+      _, stderr, status = Open3.capture3("belt", "destroy", "environment", env_name, "--full", chdir: worktree)
+
+      if status.success?
+        LOG.info "[Belt] Successfully destroyed environment '#{env_name}'"
+        BeltConfig.mark_ephemeral_destroyed(env_name)
+        true
+      else
+        LOG.error "[Belt] Failed to destroy environment '#{env_name}': #{stderr.strip}"
+        false
+      end
+    rescue StandardError => e
+      LOG.error "[Belt] Error destroying environment: #{e.message}"
+      false
+    end
+
+    # Check if changes are frontend-only by examining the diff.
+    # Frontend-only changes can be deployed faster with `belt deploy frontend <env>`.
+    #
+    # @param worktree [String] Path to the worktree
+    # @param base_branch [String, nil] Optional base (e.g. "master", "origin/main").
+    #   When omitted, uses origin/HEAD, then origin/main, then origin/master.
+    # @return [Boolean] True if changes are frontend-only
+    def frontend_only_changes?(worktree:, base_branch: nil)
+      base_ref = resolve_frontend_diff_base(worktree, base_branch)
+      unless base_ref
+        LOG.warn "[Belt] No base ref for frontend-only check in #{worktree}"
+        return false
+      end
+
+      stdout, stderr, status = Open3.capture3("git", "diff", "--name-only", base_ref, "--", chdir: worktree)
+      unless status.success?
+        LOG.warn "[Belt] Could not diff against #{base_ref}: #{stderr.strip}"
+        return false
+      end
+
+      changed_files = stdout.strip.split("\n")
+      return false if changed_files.empty?
+
+      # Frontend directories that don't affect backend
+      frontend_patterns = %w[
+        frontend/
+        app/javascript/
+        app/assets/
+        public/
+        static/
+        src/
+      ]
+
+      # Backend patterns that require full deploy
+      backend_patterns = %w[
+        lambda/
+        infrastructure/
+        config/routes
+        config/contracts
+        Gemfile
+        *.gemspec
+        Rakefile
+      ]
+
+      # Check if all changes are frontend-only
+      changed_files.all? do |file|
+        frontend_patterns.any? { |pattern| file.start_with?(pattern) } &&
+          backend_patterns.none? { |pattern| file.start_with?(pattern.delete("*")) || File.fnmatch?(pattern, file) }
+      end
+    rescue StandardError => e
+      LOG.warn "[Belt] Error checking frontend-only changes: #{e.message}"
+      false
+    end
+
+    # Resolve a git ref to diff against. Never assumes origin/main.
+    # Prefer an explicit PR/base branch, then origin/HEAD, then main/master.
+    def resolve_frontend_diff_base(worktree, explicit)
+      candidates = []
+      if explicit && !explicit.to_s.strip.empty?
+        ref = explicit.to_s.strip
+        ref = "origin/#{ref}" unless ref.include?("/")
+        candidates << ref
+      end
+
+      head = origin_head_branch(worktree)
+      candidates << "origin/#{head}" if head
+      candidates.push("origin/main", "origin/master")
+      candidates.uniq.find { |ref| git_commit?(worktree, ref) }
+    end
+
+    def origin_head_branch(worktree)
+      stdout, _stderr, status = Open3.capture3(
+        "git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD",
+        chdir: worktree
+      )
+      return nil unless status.success?
+
+      name = stdout.strip.delete_prefix("origin/")
+      name.empty? ? nil : name
+    rescue StandardError
+      nil
+    end
+
+    def git_commit?(worktree, ref)
+      _stdout, _stderr, status = Open3.capture3(
+        "git", "rev-parse", "--verify", "#{ref}^{commit}",
+        chdir: worktree
+      )
+      status.success?
+    rescue StandardError
+      false
+    end
+
+    def deploy_cancelled?(stdout, stderr)
+      [stdout, stderr].any? { |s| s.to_s.match?(/\bCancelled\.?\s*$/) }
+    end
+
+    def log_cli_tail(stdout, stderr, limit: 25)
+      lines = []
+      lines.concat(stdout.to_s.lines) unless stdout.to_s.strip.empty?
+      lines.concat(stderr.to_s.lines.map { |l| "stderr: #{l}" }) unless stderr.to_s.strip.empty?
+      return if lines.empty?
+
+      tail = lines.last(limit).join
+      LOG.info "[Belt] Output (last #{[lines.size, limit].min} lines):\n#{tail}"
+    end
+  end
+end

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.0.28"
+  VERSION = "0.0.29"
 end

data/receiver.rb

@@ -28,6 +28,7 @@ require_relative "lib/brainiac/intent"
 require_relative "lib/brainiac/plugins"
 require_relative "lib/brainiac/handlers/shared/git"
 require_relative "lib/brainiac/handlers/shared/inline_tags"
+require_relative "lib/brainiac/handlers/shared/belt"
 
 # Namespace for gem-based plugins (brainiac-whatsapp, brainiac-slack, etc.)
 module Brainiac
@@ -120,6 +121,9 @@ end
 # from within Sinatra route handlers
 helpers GitHelpers
 
+# Register BeltHelpers for Belt app detection
+helpers BeltHelpers
+
 # Dashboard authentication helpers
 helpers do
   def authenticate_dashboard!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.0.29
 platform: ruby
 authors:
 - Andy Davis
@@ -130,6 +130,7 @@ files:
 - lib/brainiac/brain.rb
 - lib/brainiac/config.rb
 - lib/brainiac/cron.rb
+- lib/brainiac/handlers/shared/belt.rb
 - lib/brainiac/handlers/shared/git.rb
 - lib/brainiac/handlers/shared/inline_tags.rb
 - lib/brainiac/helpers.rb