space-architect 1.3.0 → 2.0.0.rc2

data/lib/space_core/cli/helpers.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+module Space::Core::CLI
+module Helpers
+  include Dry::Monads[:result]
+  def project_config
+    @project_config ||= Space::Core::Config.load
+  end
+
+  def state
+    @state ||= Space::Core::State.load
+  end
+
+  def store
+    @store ||= Space::Core::SpaceStore.new(config: project_config, state: state)
+  end
+
+  def terminal
+    @terminal
+  end
+
+  def setup_terminal(color: "auto", colors: nil)
+    @terminal = Space::Core::Terminal.new(
+      config: project_config,
+      stdout: out,
+      stderr: err,
+      color_mode: colors || color || "auto"
+    )
+  end
+
+  def display_date(space)
+    id_date = space.id.match(/\A(\d{4})(\d{2})(\d{2})/)
+    return "#{id_date[1]}-#{id_date[2]}-#{id_date[3]}" if id_date
+
+    space.data["created_at"].to_s[0, 10]
+  end
+
+  def handle_errors
+    yield
+  rescue Space::Core::Error => e
+    if terminal
+      terminal.error(e.message)
+    else
+      err.puts e.message
+    end
+    CLI.record_outcome(Outcome.new(exit_code: 1, message: e.message))
+  end
+
+  def render(result)
+    case result
+    when Dry::Monads::Result::Success
+      yield result.value! if block_given?
+    when Dry::Monads::Result::Failure
+      error = result.failure
+      message = error.respond_to?(:message) ? error.message : error.to_s
+      terminal ? terminal.error(message) : err.puts(message)
+      CLI.record_outcome(Outcome.new(exit_code: 1, message: message))
+    end
+  end
+end
+
+class RepoProgress
+  def initialize(total)
+    @total = total
+    @statuses = {}
+  end
+
+  def start(addition)
+    source = addition[:src_source]
+    @statuses[addition.fetch(:reference).full_name] = source&.directory? ? :copying : :cloning
+  end
+
+  def trust(addition)
+    @statuses[addition.fetch(:reference).full_name] = :trusting
+  end
+
+  def finish(addition)
+    @statuses[addition.fetch(:reference).full_name] = :done
+  end
+
+  def fail(addition)
+    @statuses[addition.fetch(:reference).full_name] = :failed
+  end
+
+  def message
+    done = @statuses.count { |_repo, status| status == :done }
+    failed = @statuses.count { |_repo, status| status == :failed }
+    copying = @statuses.select { |_repo, status| status == :copying }.keys
+    cloning = @statuses.select { |_repo, status| status == :cloning }.keys
+    trusting = @statuses.select { |_repo, status| status == :trusting }.keys
+
+    if @total == 1
+      copying_repo = copying.first
+      cloning_repo = cloning.first
+      trusting_repo = trusting.first
+      return "Copying #{copying_repo}" if copying_repo
+      return "Cloning #{cloning_repo}" if cloning_repo
+      return "Trusting #{trusting_repo}" if trusting_repo
+      return "Fetch failed" if failed.positive?
+
+      "Preparing repos"
+    else
+      active = []
+      active << "copying #{copying.join(', ')}" unless copying.empty?
+      active << "cloning #{cloning.join(', ')}" unless cloning.empty?
+      active << "trusting #{trusting.join(', ')}" unless trusting.empty?
+      suffix = active.empty? ? nil : ": #{active.join('; ')}"
+      failed_text = failed.positive? ? ", #{failed} failed" : ""
+      "Fetching repos #{done}/#{@total}#{failed_text}#{suffix}"
+    end
+  end
+end
+end

data/lib/space_core/cli/init.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class Init < BaseCommand
+  desc "Create default XDG config and state files"
+  option :force, type: :boolean, default: false, desc: "Overwrite existing config and state files"
+
+  def call(force: false, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      if force
+        @project_config = Space::Core::Config.new
+        @state = Space::Core::State.new
+        project_config.save
+        state.save
+      else
+        project_config.ensure_exists!
+        state.ensure_exists!
+      end
+
+      FileUtils.mkdir_p(project_config.spaces_dir)
+      terminal.success "Config: #{terminal.path(project_config.path)}"
+      terminal.success "State: #{terminal.path(state.path)}"
+      terminal.success "Spaces: #{terminal.path(project_config.spaces_dir)}"
+      CLI.record_outcome(Outcome.new(exit_code: 0))
+    end
+  end
+end
+end

data/lib/space_core/cli/list.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class List < BaseCommand
+  desc "List spaces"
+
+  def call(**opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      spaces = store.list
+      if spaces.empty?
+        terminal.say "No spaces found in #{terminal.path(project_config.spaces_dir)}"
+        next
+      end
+
+      rows = spaces.map do |space|
+        [space.status, display_date(space), space.title, terminal.path(space.path)]
+      end
+      terminal.say terminal.table(%w[Status Date Title Path], rows)
+      CLI.record_outcome(Outcome.new(exit_code: 0))
+    end
+  end
+end
+end

data/lib/space_core/cli/new.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class New < BaseCommand
+  desc "Create a new project space"
+  argument :title, required: true, desc: "Space title"
+  option :repo, type: :array, aliases: ["-r"], desc: "Repo ref to clone (repeatable: pass -r once per repo)"
+  option :git, type: :boolean, default: true, desc: "Initialize the space as a Git repository (use --no-git to skip)"
+  example "\"My Space\" -r org/repo -r example-tools/alpha   # clone two repos into the space"
+
+  def call(title:, repo: [], git: true, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    result = store.create(title, git: git).bind do |space|
+      terminal.success "Created #{space.id}"
+
+      repo_specs = Array(repo).compact
+      repo_specs.each { |spec| terminal.say "Queued #{spec}" }
+
+      next Success(space) if repo_specs.empty?
+
+      progress = RepoProgress.new(repo_specs.length)
+      terminal.with_spinner(-> { progress.message }) do
+        store.add_repos_to(space, repo_specs, reporter: progress)
+      end.fmap do |results|
+        results.each do |r|
+          terminal.success "Added #{r.fetch(:repo).fetch('full_name')}"
+          terminal.say terminal.path(r.fetch(:path))
+        end
+        space
+      end
+    end
+    render(result) do |space|
+      terminal.say terminal.path(space.path)
+      CLI.record_outcome(Outcome.new(exit_code: 0))
+    end
+  end
+end
+end

data/lib/space_core/cli/pack.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../oci_packer"
+
+module Space::Core::CLI
+class Pack < BaseCommand
+  desc "Generate a portable OCI build context for the current space"
+  option :output, aliases: ["-o"], type: :string, default: nil,
+         desc: "Output directory (default: build/oci/ under the space root)"
+
+  def call(output: nil, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      result = store.current.bind do |space|
+        out_dir = output ? Pathname.new(output).expand_path : space.path.join("build", "oci")
+        Space::Core::OciPacker.new(space: space, output_dir: out_dir).generate
+          .fmap { |dir| { space: space, dir: dir } }
+      end
+      render(result) do |r|
+        terminal.success "Generated OCI context: #{r[:dir]}"
+        terminal.say "Build: docker build -f #{r[:dir]}/Dockerfile -t #{r[:space].id}:latest ."
+        terminal.say "  (run from: #{r[:space].path})"
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+end
+end

data/lib/space_core/cli/path.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class Path < BaseCommand
+  desc "Print the path for a space or the current space"
+  argument :identifier, required: false, desc: "Space ID or title slug"
+
+  def call(identifier: nil, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    render(store.path_for(identifier)) do |path|
+      terminal.say terminal.path(path)
+      CLI.record_outcome(Outcome.new(exit_code: 0))
+    end
+  end
+end
+end

data/lib/space_core/cli/repeatable_options.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+
+# dry-cli (1.4.x) treats `type: :array` options as comma-separated and OVERWRITES
+# on each occurrence, so `-r a -r b` yields ["b"]. We want repeated flags to
+# accumulate (`-r a -r b -r c` => ["a", "b", "c"]) the way git/docker-style CLIs
+# do, while still accepting the comma form. dry-cli exposes no hook for this, so
+# we reopen two private seams, each mirroring dry-cli 1.4.1 with a single change:
+#
+#   * Parser.call                  — concat instead of assign for array options.
+#   * Banner.extended_command_options — drop the "=VALUE1,VALUE2,.." hint that
+#     advertised the comma form as the only way; show the plain repeatable flag,
+#     matching how you actually type it (-r VALUE).
+#
+# These mirror the released 1.4.1 source EXACTLY (not the dry-rb main branch,
+# which already differs). Pinned via `~> 1.4`; if a future dry-cli reworks these
+# methods, repeatable_options_test goes red and we re-sync. Rationale:
+# notes/ruby-cli-gems-report.md.
+module Dry
+  class CLI
+    module Parser
+      def self.call(command, arguments, prog_name)
+        original_arguments = arguments.dup
+        parsed_options = {}
+
+        OptionParser.new do |opts|
+          command.options.each do |option|
+            opts.on(*option.parser_options) do |value|
+              if option.array?
+                (parsed_options[option.name.to_sym] ||= []).concat(value)
+              else
+                parsed_options[option.name.to_sym] = value
+              end
+            end
+          end
+
+          opts.on_tail("-h", "--help") do
+            return Result.help
+          end
+        end.parse!(arguments)
+
+        parsed_options = command.default_params.merge(parsed_options)
+        parse_required_params(command, arguments, prog_name, parsed_options)
+      rescue ::OptionParser::ParseError, ValueError
+        Result.failure("ERROR: \"#{prog_name}\" was called with arguments \"#{original_arguments.join(" ")}\"")
+      end
+    end
+
+    module Banner
+      def self.extended_command_options(command)
+        result = command.options.map do |option|
+          name = Inflector.dasherize(option.name)
+          name = if option.boolean?
+                   "[no-]#{name}"
+                 elsif option.flag?
+                   name
+                 else
+                   # array options included: repeated flags accumulate, so show
+                   # the single repeatable form rather than "=VALUE1,VALUE2,..".
+                   "#{name}=VALUE"
+                 end
+          name = "#{name}, #{option.alias_names.join(", ")}" if option.aliases.any?
+          name = "  --#{name.ljust(30)}"
+          name = "#{name}  # #{option.desc}"
+          name = "#{name}, default: #{option.default.inspect}" unless option.default.nil?
+          name
+        end
+
+        result << "  --#{"help, -h".ljust(30)}  # Print this help"
+        result.join("\n")
+      end
+    end
+  end
+end

data/lib/space_core/cli/repo.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+module Repo
+  class Add < BaseCommand
+    desc "Add repos to the current space (copy-on-write from an evergreen checkout when available, else clone)"
+    argument :repos, type: :array, required: false, desc: "REPO [REPO...]"
+
+    def call(repos: [], **opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        specs = Array(repos).compact
+        if specs.empty?
+          terminal.error("Usage: space repo add REPO [REPO...]")
+          CLI.record_outcome(Outcome.new(exit_code: 1))
+          next
+        end
+
+        progress = RepoProgress.new(specs.length)
+        add_result = terminal.with_spinner(-> { progress.message }) do
+          store.add_repos(specs, reporter: progress)
+        end
+        render(add_result) do |results|
+          results.each do |result|
+            terminal.success "Added #{result.fetch(:repo).fetch('full_name')}"
+            terminal.say terminal.path(result.fetch(:path))
+          end
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+    end
+  end
+
+  class RepoList < BaseCommand
+    desc "List repos in the current space"
+
+    def call(**opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        render(store.repos) do |repos|
+          if repos.empty?
+            id = store.find.fmap(&:id).value_or("(unknown space)")
+            terminal.say "No repos found in #{id}"
+            next
+          end
+
+          rows = repos.map { |repo| [repo.fetch("full_name", repo["name"]), repo.fetch("path", "")] }
+          terminal.say terminal.table(["Repo", "Path"], rows)
+          CLI.record_outcome(Outcome.new(exit_code: 0))
+        end
+      end
+    end
+  end
+
+  class Resolve < BaseCommand
+    desc "Resolve repo refs without cloning"
+    argument :repos, type: :array, required: false, desc: "REPO [REPO...]"
+
+    def call(repos: [], **opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        specs = Array(repos).compact
+        if specs.empty?
+          terminal.error("Usage: space repo resolve REPO [REPO...]")
+          CLI.record_outcome(Outcome.new(exit_code: 1))
+          next
+        end
+
+        references = specs.map { |spec| Space::Core::RepoResolver.new(project_config).resolve(spec) }
+        terminal.say terminal.table(["Repo", "Clone URL"], references.map { |ref| [ref.full_name, ref.clone_url] })
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+end
+end

data/lib/space_core/cli/run.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../oci_runner"
+
+module Space::Core::CLI
+class Run < BaseCommand
+  desc "Run the packed OCI image for the current space (auth injected at runtime)"
+
+  argument :command, type: :array, required: false, desc: "Command to run in the container (default: login shell)"
+  option :tty, type: :boolean, default: nil, desc: "Force interactive TTY (default: auto-detect)"
+
+  def call(command: [], tty: nil, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      result = store.current.bind do |space|
+        runner = Space::Core::OciRunner.new(space: space, interactive: tty.nil? ? CLI.tty?(out) : tty)
+        runner.command(command).fmap { |argv| { argv: argv, runner: runner } }
+      end
+      render(result) do |r|
+        r[:runner].host_dirs.each { |d| FileUtils.mkdir_p(d) }
+        terminal.say "Running: #{r[:argv].join(' ')}"
+        out.flush # Kernel.exec replaces the process without flushing buffered IO
+        Kernel.exec(*r[:argv])
+      end
+    end
+  end
+end
+end

data/lib/space_core/cli/shell.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+module Shell
+  class ShellInit < BaseCommand
+    desc "Print shell integration script"
+    argument :shell_name, required: true, desc: "Shell name (e.g. fish)"
+
+    def call(shell_name:, **opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        terminal.say Space::Core::ShellIntegration.for(shell_name)
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+
+  class Fish < BaseCommand
+    desc "Manage fish shell integration: install, uninstall, path"
+    argument :subcommand, required: false, desc: "install, uninstall, or path (default: install)"
+    option :force, type: :boolean, default: false, desc: "Overwrite or remove existing shell files"
+
+    def call(subcommand: "install", force: false, **opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        case subcommand
+        when "install"
+          result = Space::Core::ShellIntegration.install("fish", env: project_config.env, force: force)
+          terminal.success fish_install_message(result.fetch(:action), result.fetch(:path))
+          terminal.success fish_completions_install_message(result.fetch(:completions_action), result.fetch(:completions_path))
+          terminal.say "Restart fish to load the integration in this terminal: exec fish"
+        when "uninstall"
+          result = Space::Core::ShellIntegration.uninstall("fish", env: project_config.env, force: force)
+          terminal.success fish_uninstall_message(result.fetch(:action), result.fetch(:path))
+          terminal.success fish_completions_uninstall_message(result.fetch(:completions_action), result.fetch(:completions_path))
+        when "path"
+          terminal.say "Function:    #{terminal.path(Space::Core::ShellIntegration.path_for('fish', env: project_config.env))}"
+          terminal.say "Completions: #{terminal.path(Space::Core::ShellIntegration.completions_path_for('fish', env: project_config.env))}"
+        else
+          err.puts "Usage: space shell fish [install|uninstall|path]"
+          CLI.record_outcome(Outcome.new(exit_code: 1))
+          next
+        end
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+
+    private
+
+    def fish_install_message(action, path)
+      case action
+      when :unchanged then "Fish integration already installed: #{terminal.path(path)}"
+      when :updated   then "Updated fish integration: #{terminal.path(path)}"
+      else                 "Installed fish integration: #{terminal.path(path)}"
+      end
+    end
+
+    def fish_uninstall_message(action, path)
+      case action
+      when :missing then "Fish integration was not installed: #{terminal.path(path)}"
+      else               "Removed fish integration: #{terminal.path(path)}"
+      end
+    end
+
+    def fish_completions_install_message(action, path)
+      case action
+      when :unchanged then "Fish completions already installed: #{terminal.path(path)}"
+      when :updated   then "Updated fish completions: #{terminal.path(path)}"
+      else                 "Installed fish completions: #{terminal.path(path)}"
+      end
+    end
+
+    def fish_completions_uninstall_message(action, path)
+      case action
+      when :missing then "Fish completions were not installed: #{terminal.path(path)}"
+      else               "Removed fish completions: #{terminal.path(path)}"
+      end
+    end
+  end
+
+  class Complete < BaseCommand
+    desc "Print completion candidates"
+    argument :kind, required: true, desc: "Completion kind"
+    argument :extra, type: :array, required: false, desc: "Extra args for completion"
+
+    def call(kind:, extra: [], **opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        completion_candidates(kind, Array(extra)).each { |c| terminal.say c }
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+
+    private
+
+    def completion_candidates(kind, args)
+      case kind
+      when "spaces"          then store.list.map { |space| "#{space.id}\t#{space.title}" }
+      when "statuses"        then Space::Core::Space::VALID_STATUSES
+      when "config-keys"     then Space::Core::Config::EDITABLE_KEYS
+      when "config-values"   then completion_values_for_config_key(args.first)
+      when "shells"          then ["fish"]
+      when "color-modes"     then %w[auto always never]
+      when "repo-subcommands"   then %w[add list ls resolve]
+      when "config-subcommands" then %w[show path set]
+      when "fish-subcommands"   then %w[install uninstall path]
+      else
+        raise Space::Core::Error, "Usage: space shell complete #{completion_kinds.join('|')}"
+      end
+    end
+
+    def completion_values_for_config_key(key)
+      case key
+      when "git_clone_protocol" then Space::Core::Config::VALID_GIT_CLONE_PROTOCOLS
+      when "default_provider"   then %w[github.com gitlab.com]
+      else []
+      end
+    end
+
+    def completion_kinds
+      %w[spaces statuses config-keys config-values shells color-modes repo-subcommands config-subcommands fish-subcommands]
+    end
+  end
+end
+end

data/lib/space_core/cli/show.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class Show < BaseCommand
+  desc "Show metadata for a space or the current space"
+  argument :identifier, required: false, desc: "Space ID or title slug"
+
+  def call(identifier: nil, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    render(store.find(identifier)) do |space|
+      terminal.say "ID:         #{space.id}"
+      terminal.say "Title:      #{space.title}"
+      terminal.say "Status:     #{space.status}"
+      terminal.say "Path:       #{terminal.path(space.path)}"
+      terminal.say "Created:    #{space.data['created_at']}"
+      terminal.say "Updated:    #{space.data['updated_at']}"
+      CLI.record_outcome(Outcome.new(exit_code: 0))
+    end
+  end
+end
+end

data/lib/space_core/cli/status.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class Status < BaseCommand
+  desc "Set a space status: active, paused, done, archived"
+  argument :rest, type: :array, required: false, desc: "[SPACE] STATUS"
+
+  def call(rest: [], **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    handle_errors do
+      identifier, status_value = parse_status_args(Array(rest))
+      render(store.find(identifier)) do |space|
+        space.update_status(status_value)
+        terminal.success "#{space.id} is #{space.status}"
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+
+  private
+
+  def parse_status_args(args)
+    case args.length
+    when 1
+      [nil, args.first]
+    when 2
+      args
+    else
+      raise Space::Core::Error, "Usage: space status [SPACE] STATUS"
+    end
+  end
+end
+end

data/lib/space_core/cli/use.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class Use < BaseCommand
+  desc "Remember a space in recent state and print its path"
+  argument :identifier, required: true, desc: "Space ID or title slug"
+
+  def call(identifier:, **opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    render(store.use(identifier)) do |space|
+      terminal.success "Recent space: #{space.id}"
+      terminal.say terminal.path(space.path)
+      CLI.record_outcome(Outcome.new(exit_code: 0))
+    end
+  end
+end
+end