space-architect 1.3.0 → 2.0.0.rc2

data/lib/space_core/cli.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "pastel"
+require_relative "cli/repeatable_options"
+require_relative "cli/help"
+
+module Space::Core
+  module CLI
+    CLI = self
+
+    Outcome = Data.define(:exit_code, :message) do
+      def initialize(exit_code:, message: nil) = super
+    end
+
+    def self.record_outcome(o) = (Thread.current[:space_core_cli_outcome] = o)
+    def self.last_outcome = Thread.current[:space_core_cli_outcome]
+
+    # Pastel used by the colourful help listing (Help / the Usage reopen). Set
+    # per-invocation in .call from the output stream and --color; defaults to a
+    # disabled instance so non-CLI callers and tests render plain text.
+    def self.help_pastel = @help_pastel ||= Pastel.new(enabled: false)
+
+    def self.help_pastel=(pastel)
+      @help_pastel = pastel
+    end
+
+    # Whether the help listing should be colourised: honour an explicit
+    # --color/--colors (always/never), otherwise auto-detect from the streams the
+    # listing can land on (stdout for top-level help, stderr for bare namespaces).
+    def self.help_colors?(argv, out, err)
+      case color_mode(argv)
+      when "always" then true
+      when "never"  then false
+      else tty?(out) || tty?(err)
+      end
+    end
+
+    def self.tty?(io) = io.respond_to?(:tty?) && io.tty?
+
+    def self.color_mode(argv)
+      argv.each_with_index do |arg, i|
+        return arg.split("=", 2)[1].to_s.downcase if arg.start_with?("--color=", "--colors=")
+        return argv[i + 1].to_s.downcase if %w[--color --colors].include?(arg)
+      end
+      "auto"
+    end
+
+    module Registry
+      extend Dry::CLI::Registry
+    end
+
+    TOP_LEVEL_HELP  = [[], ["--help"], ["-h"], ["help"]].freeze
+    VERSION_REQUEST = [["version"], ["--version"]].freeze
+
+    def self.call(argv, out = $stdout, err = $stderr)
+      Thread.current[:space_core_cli_outcome] = nil
+      self.help_pastel = Pastel.new(enabled: help_colors?(argv, out, err))
+
+      if TOP_LEVEL_HELP.include?(argv)
+        print_usage(out)
+        return 0
+      end
+
+      if VERSION_REQUEST.include?(argv)
+        print_version(out)
+        return 0
+      end
+
+      Dry::CLI.new(Registry).call(arguments: normalize_args(argv), out: out, err: err)
+      last_outcome&.exit_code || 0
+    end
+
+    # Move --color/--colors options to the end of the argument list so dry-cli's
+    # command routing is not confused by options before the subcommand name.
+    #
+    # Two passes:
+    #   1. Leading: extract two-token form (--color VALUE) and =-form from the
+    #      front while args still look like options.
+    #   2. Non-leading: extract =-form (--color=VALUE / --colors=VALUE) from any
+    #      position before the -- separator. The bare two-token form is ambiguous
+    #      with a subcommand name in non-leading position and is left in place.
+    def self.normalize_args(argv)
+      args = argv.dup
+      extracted = []
+
+      # Pass 1: leading two-token and =-form (existing behavior, unchanged)
+      while (arg = args.first) && arg != "--" && arg.start_with?("-")
+        if %w[--color --colors].include?(arg)
+          extracted << args.shift
+          extracted << args.shift if args.first && !args.first.start_with?("-")
+        elsif arg.start_with?("--color=", "--colors=")
+          extracted << args.shift
+        else
+          break
+        end
+      end
+
+      # Pass 2: =-form from any non-leading position, stop at --
+      sep = args.index("--")
+      head = sep ? args[0, sep] : args
+      tail = sep ? args[sep..] : []
+      mid_color, head = head.partition { |a| a.start_with?("--color=", "--colors=") }
+      extracted += mid_color
+      args = head + tail
+
+      extracted.empty? ? args : args + extracted
+    end
+
+    def self.print_usage(out)
+      out.puts Dry::CLI::Usage.call(Registry.get([]))
+    end
+
+    def self.print_version(out)
+      out.puts ::Space::Core::VERSION
+    end
+
+    def self.run(argv, out = $stdout, err = $stderr)
+      Kernel.exit(call(argv, out, err))
+    rescue Interrupt
+      err.puts "interrupted"
+      Kernel.exit(130)
+    end
+  end
+end
+
+require_relative "cli/helpers"
+require_relative "cli/base_command"
+require_relative "cli/init"
+require_relative "cli/new"
+require_relative "cli/list"
+require_relative "cli/show"
+require_relative "cli/path"
+require_relative "cli/use"
+require_relative "cli/current"
+require_relative "cli/status"
+require_relative "cli/config"
+require_relative "cli/repo"
+require_relative "cli/shell"
+require_relative "cli/pack"
+require_relative "cli/build"
+require_relative "cli/run"
+
+Space::Core::CLI::Registry.register "init",    Space::Core::CLI::Init
+Space::Core::CLI::Registry.register "new",     Space::Core::CLI::New
+Space::Core::CLI::Registry.register "list",    Space::Core::CLI::List
+Space::Core::CLI::Registry.register "ls",      Space::Core::CLI::List
+Space::Core::CLI::Registry.register "show",    Space::Core::CLI::Show
+Space::Core::CLI::Registry.register "path",    Space::Core::CLI::Path
+Space::Core::CLI::Registry.register "use",     Space::Core::CLI::Use
+Space::Core::CLI::Registry.register "current", Space::Core::CLI::Current
+Space::Core::CLI::Registry.register "status",  Space::Core::CLI::Status
+Space::Core::CLI::Registry.register "config" do |c|
+  c.register "show", Space::Core::CLI::Config::Show
+  c.register "path", Space::Core::CLI::Config::ConfigPath
+  c.register "set",  Space::Core::CLI::Config::Set
+end
+Space::Core::CLI::Registry.register "repo" do |r|
+  r.register "add",     Space::Core::CLI::Repo::Add
+  r.register "list",    Space::Core::CLI::Repo::RepoList
+  r.register "ls",      Space::Core::CLI::Repo::RepoList
+  r.register "resolve", Space::Core::CLI::Repo::Resolve
+end
+Space::Core::CLI::Registry.register "repos" do |r|
+  r.register "add",     Space::Core::CLI::Repo::Add
+  r.register "list",    Space::Core::CLI::Repo::RepoList
+  r.register "ls",      Space::Core::CLI::Repo::RepoList
+  r.register "resolve", Space::Core::CLI::Repo::Resolve
+end
+Space::Core::CLI::Registry.register "shell" do |s|
+  s.register "init",     Space::Core::CLI::Shell::ShellInit
+  s.register "fish",     Space::Core::CLI::Shell::Fish
+  s.register "complete", Space::Core::CLI::Shell::Complete
+end
+Space::Core::CLI::Registry.register "pack",  Space::Core::CLI::Pack
+Space::Core::CLI::Registry.register "build", Space::Core::CLI::Build
+Space::Core::CLI::Registry.register "run",   Space::Core::CLI::Run

data/lib/{space_architect → space_core}/config.rb

@@ -3,7 +3,7 @@
 require "yaml"
 require "pathname"
 
-module SpaceArchitect
+module Space::Core
   class Config
     DEFAULT_DATA = {
       "version" => 1,

data/lib/{space_architect → space_core}/errors.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpaceArchitect
+module Space::Core
   class Error < StandardError; end
   class NotFoundError < Error; end
   class AmbiguousSpaceError < Error; end

data/lib/{space_architect → space_core}/git_client.rb

@@ -5,7 +5,7 @@ require "async/process"
 require "pathname"
 require "tempfile"
 
-module SpaceArchitect
+module Space::Core
   class GitClient
     def init(path)
       path = Pathname.new(path)

data/lib/{space_architect → space_core}/mise_client.rb

@@ -4,7 +4,7 @@ require "async/process"
 require "pathname"
 require "tempfile"
 
-module SpaceArchitect
+module Space::Core
   class MiseClient
     def trust(path)
       path = Pathname.new(path)

data/lib/space_core/oci_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+require "dry/monads"
+
+module Space::Core
+  class OciBuilder
+    include Dry::Monads[:result]
+
+    def initialize(space:, output_dir:)
+      @space = space
+      @output_dir = Pathname.new(output_dir)
+    end
+
+    def version
+      compute_version.value!
+    end
+
+    def image
+      "#{space.id}:#{version}"
+    end
+
+    def latest
+      "#{space.id}:latest"
+    end
+
+    def command
+      compute_version.fmap do |ver|
+        [
+          "container", "build",
+          "-f", @output_dir.join("Dockerfile").to_s,
+          "-t", "#{space.id}:#{ver}",
+          "-t", latest,
+          space.path.to_s
+        ]
+      end
+    end
+
+    private
+
+    attr_reader :space
+
+    def compute_version
+      sha_out, _, sha_status = Open3.capture3("git", "-C", space.path.to_s, "rev-parse", "--short=12", "HEAD")
+      unless sha_status.success?
+        return Failure("space is not a git repository with a commit; cannot compute a version tag")
+      end
+
+      sha = sha_out.strip
+      status_out, _, _ = Open3.capture3("git", "-C", space.path.to_s, "status", "--porcelain")
+      dirty = !status_out.strip.empty?
+      Success(dirty ? "#{sha}-dirty" : sha)
+    end
+  end
+end

data/lib/space_core/oci_packer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+require "pathname"
+require "dry/monads"
+
+module Space::Core
+  class OciPacker
+    include Dry::Monads[:result]
+
+    TEMPLATE_DIR = Pathname.new(__dir__).join("templates", "oci").freeze
+
+    def initialize(space:, output_dir:)
+      @space = space
+      @output_dir = Pathname.new(output_dir)
+    end
+
+    def generate
+      FileUtils.mkdir_p(@output_dir)
+      validated = validate_provision_scripts(space.provision_scripts)
+      return validated if validated.failure?
+      validated = validate_persist_paths(space.persist_paths)
+      return validated if validated.failure?
+      write("Dockerfile",    render_template("dockerfile.erb"))
+      write("entrypoint.sh", entrypoint_content, mode: 0o755)
+      write("Dockerfile.dockerignore", render_template("dockerignore.erb"))
+      Success(@output_dir)
+    rescue StandardError => e
+      Failure(e)
+    end
+
+    private
+
+    attr_reader :space, :output_dir
+
+    def space_id
+      @space.id
+    end
+
+    def repos
+      @space.repos
+    end
+
+    def provision_scripts
+      @space.provision_scripts
+    end
+
+    def persist_paths
+      @space.persist_paths
+    end
+
+    def validate_provision_scripts(scripts)
+      scripts.each do |rel_path|
+        if Pathname.new(rel_path).absolute?
+          return Failure("provision script '#{rel_path}' must not be an absolute path")
+        end
+
+        resolved = space.path.join(rel_path).cleanpath
+        space_root = space.path.cleanpath
+        unless resolved.to_s.start_with?("#{space_root}/") || resolved == space_root
+          return Failure("provision script '#{rel_path}' escapes the space root")
+        end
+
+        return Failure("provision script '#{rel_path}' does not exist under the space root") unless resolved.exist?
+      end
+      Success(scripts)
+    end
+
+    def validate_persist_paths(paths)
+      paths.each do |path|
+        unless Pathname.new(path).absolute?
+          return Failure("persist path '#{path}' must be an absolute path")
+        end
+      end
+      Success(paths)
+    end
+
+    def entrypoint_content
+      @entrypoint_content ||= render_template("entrypoint.sh.erb")
+    end
+
+    def entrypoint_b64
+      [entrypoint_content].pack("m0")
+    end
+
+    def render_template(name)
+      template_path = TEMPLATE_DIR.join(name)
+      ERB.new(template_path.read, trim_mode: "-").result(binding)
+    end
+
+    def write(filename, content, mode: 0o644)
+      path = @output_dir.join(filename)
+      File.write(path, content)
+      File.chmod(mode, path)
+      path
+    end
+  end
+end

data/lib/space_core/oci_runner.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/monads"
+
+module Space::Core
+  class OciRunner
+    include Dry::Monads[:result]
+
+    AUTH_ENV = %w[ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_BASE_URL].freeze
+
+    def initialize(space:, env: ENV.to_h, interactive: true)
+      @space = space
+      @env = env
+      @interactive = interactive
+    end
+
+    def image
+      "#{space.id}:latest"
+    end
+
+    def mounts
+      space.persist_paths.map do |guest|
+        [space.path.join(".state" + guest), guest]
+      end
+    end
+
+    def host_dirs
+      mounts.map(&:first)
+    end
+
+    def command(extra = [])
+      validated = validate_persist_paths(space.persist_paths)
+      return validated if validated.failure?
+
+      argv = [
+        "container", "run", "--rm",
+        *(@interactive ? ["-i", "-t"] : []),
+        *auth_flags,
+        *mount_flags,
+        image,
+        *extra
+      ]
+      Success(argv)
+    end
+
+    private
+
+    attr_reader :space, :env, :interactive
+
+    def auth_flags
+      AUTH_ENV.each_with_object([]) do |var, flags|
+        val = env[var]
+        flags.push("-e", var) if val && !val.empty?
+      end
+    end
+
+    def mount_flags
+      mounts.each_with_object([]) do |(host, guest), flags|
+        flags.push("-v", "#{host}:#{guest}")
+      end
+    end
+
+    def validate_persist_paths(paths)
+      paths.each do |path|
+        unless Pathname.new(path).absolute?
+          return Failure("persist path '#{path}' must be an absolute path")
+        end
+      end
+      Success(paths)
+    end
+  end
+end

data/lib/{space_architect → space_core}/repo_reference.rb

@@ -2,7 +2,7 @@
 
 require "pathname"
 
-module SpaceArchitect
+module Space::Core
   RepoReference = Data.define(:provider, :owner, :name, :clone_url, :source) do
     def full_name
       "#{provider}/#{owner}/#{name}"

data/lib/{space_architect → space_core}/repo_resolver.rb

@@ -2,7 +2,7 @@
 
 require "uri"
 
-module SpaceArchitect
+module Space::Core
   class RepoResolver
     SCP_LIKE_PATTERN = /\A(?:[^@\/]+@)?(?<provider>[^:\/]+):(?<path>.+)\z/
     URL_PATTERN = %r{\A[A-Za-z][A-Za-z0-9+\-.]*://}

data/lib/{space_architect → space_core}/shell_integration.rb

@@ -2,7 +2,7 @@
 
 require "fileutils"
 
-module SpaceArchitect
+module Space::Core
   module ShellIntegration
     FISH_TEMPLATE = <<~'FISH'
       # Generated by space-architect. Do not edit by hand.

data/lib/{space_architect → space_core}/slugger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpaceArchitect
+module Space::Core
   module Slugger
     module_function
 

data/lib/{space_architect → space_core}/space.rb

@@ -4,7 +4,7 @@ require "yaml"
 require "pathname"
 require "time"
 
-module SpaceArchitect
+module Space::Core
   class Space
     METADATA_FILE = "space.yaml"
     VALID_STATUSES = %w[active paused done archived].freeze
@@ -48,12 +48,20 @@ module SpaceArchitect
       end
     end
 
+    def provision_scripts
+      Array(data.dig("pack", "provision")).map(&:to_s)
+    end
+
+    def persist_paths
+      Array(data.dig("pack", "persist")).map(&:to_s)
+    end
+
     def architect
-      data["architect"]
+      data["project"]
     end
 
     def architect=(val)
-      data["architect"] = val
+      data["project"] = val
     end
 
     def metadata_path

data/lib/{space_architect → space_core}/space_store.rb

@@ -6,10 +6,10 @@ require "async/semaphore"
 require "pathname"
 require "time"
 require "dry/monads"
-require "space_architect/pristine/scm/git"
-require "space_architect/pristine/cloner"
+require "space_src/scm/git"
+require "space_src/cloner"
 
-module SpaceArchitect
+module Space::Core
   class SpaceStore
     include Dry::Monads[:result, :maybe]
 
@@ -46,7 +46,7 @@ module SpaceArchitect
       init_git(path:, id:, git_client:) if git
       state.touch_recent(id)
       Success(space)
-    rescue SpaceArchitect::Error => e
+    rescue Error => e
       Failure(e)
     end
 
@@ -67,7 +67,7 @@ module SpaceArchitect
       if looks_like_path?(value)
         begin
           return Success(Space.load(File.expand_path(value)))
-        rescue SpaceArchitect::Error => e
+        rescue Error => e
           return Failure(e)
         end
       end
@@ -80,13 +80,13 @@ module SpaceArchitect
       end
 
       Failure(AmbiguousSpaceError.new("Space '#{value}' is ambiguous: #{matches.map(&:id).join(', ')}"))
-    rescue SpaceArchitect::Error => e
+    rescue Error => e
       Failure(e)
     end
 
     def current(from: Dir.pwd)
       current_from_pwd(from:).to_result(CurrentSpaceMissingError.new("No current space found from #{from}. Run this inside a space or pass a space id."))
-    rescue SpaceArchitect::Error => e
+    rescue Error => e
       Failure(e)
     end
 
@@ -112,15 +112,15 @@ module SpaceArchitect
       find(identifier).fmap { |space| state.touch_recent(space.id); space }
     end
 
-    def add_repo(spec, from: Dir.pwd, scm: Pristine::SCM::Git.new, cloner: nil, mise_client: MiseClient.new)
+    def add_repo(spec, from: Dir.pwd, scm: ::Space::Src::SCM::Git.new, cloner: nil, mise_client: MiseClient.new)
       add_repos([spec], from:, scm:, cloner:, mise_client:).fmap(&:first)
     end
 
-    def add_repos(specs, from: Dir.pwd, scm: Pristine::SCM::Git.new, cloner: nil, mise_client: MiseClient.new, reporter: nil)
+    def add_repos(specs, from: Dir.pwd, scm: ::Space::Src::SCM::Git.new, cloner: nil, mise_client: MiseClient.new, reporter: nil)
       current(from:).bind { |space| add_repos_to(space, specs, scm:, cloner:, mise_client:, reporter:) }
     end
 
-    def add_repos_to(space, specs, scm: Pristine::SCM::Git.new, cloner: nil, mise_client: MiseClient.new, reporter: nil)
+    def add_repos_to(space, specs, scm: ::Space::Src::SCM::Git.new, cloner: nil, mise_client: MiseClient.new, reporter: nil)
       additions = prepare_repo_additions(space, specs)
       first_error = nil
 
@@ -148,7 +148,7 @@ module SpaceArchitect
         repo_data = space.add_repo(addition.fetch(:reference), relative_path: addition.fetch(:relative_path), now: now.call)
         { space: space, repo: repo_data, reference: addition.fetch(:reference), path: addition.fetch(:path) }
       end)
-    rescue SpaceArchitect::Error => e
+    rescue Error => e
       Failure(e)
     end
 
@@ -178,7 +178,7 @@ module SpaceArchitect
       source = addition.fetch(:src_source)
 
       if source&.directory?
-        actual_cloner = cloner || Pristine::Cloner.new(base_dir: config.src_dir)
+        actual_cloner = cloner || ::Space::Src::Cloner.new(base_dir: config.src_dir)
         result = actual_cloner.call(name: reference.full_name, into: destination.dirname.to_s)
         raise GitError, "clone failed (copy): #{result.failure}" if result.failure?
       else
@@ -257,7 +257,7 @@ module SpaceArchitect
         - `space.yaml` tracks the space identity, status, and associated metadata.
         - `repos/` contains cloned Git repositories for this work.
         - `notes/` is for task notes, scratch docs, and thinking-in-progress.
-        - `architecture/` holds the architect mission memory (ARCHITECT.md and the per-iteration files).
+        - `architecture/` holds the architect project memory (ARCHITECT.md and the per-iteration files).
         - `tmp/` is the workspace-local scratch directory. Use it instead of `/tmp` or
           `/var/tmp`; when using `mktemp`, use `tmp/` as the base directory.
         - `build/` holds the architect loop's per-lane worktrees and scratch

data/lib/{space_architect → space_core}/state.rb

@@ -3,7 +3,7 @@
 require "yaml"
 require "pathname"
 
-module SpaceArchitect
+module Space::Core
   class State
     DEFAULT_DATA = {
       "version" => 1,

data/lib/space_core/templates/oci/dockerfile.erb

@@ -0,0 +1,63 @@
+# Generated by `space pack` for space: <%= space_id %>
+# Build (run from the space root):
+#   docker build -f <output_dir>/Dockerfile -t <%= space_id %>:latest .
+#
+# Run (auth injected at runtime — never baked into layers):
+#   container run --rm -it \
+#     -e ANTHROPIC_API_KEY=<key> \
+<% persist_paths.each do |guest_path| -%>
+#     -v .state<%= guest_path %>:<%= guest_path %> \
+<% end -%>
+#     <%= space_id %>:latest
+<% if persist_paths.any? -%>
+# (Persist: host paths are relative to space root; create them before first run.)
+<% end -%>
+#
+# Available env vars at runtime:
+#   ANTHROPIC_API_KEY          — API key
+#   CLAUDE_CODE_OAUTH_TOKEN    — alternative to API key
+#   ANTHROPIC_BASE_URL         — optional proxy endpoint
+
+FROM ruby:4.0.5
+
+RUN apt-get update -qq \
+ && apt-get install -y --no-install-recommends \
+      git \
+      curl \
+      ca-certificates \
+ && rm -rf /var/lib/apt/lists/*
+
+# Claude Code CLI (https://claude.ai/install.sh)
+RUN curl -fsSL https://claude.ai/install.sh | bash
+
+# Copy the space tree into the image (filtered by Dockerfile.dockerignore alongside this Dockerfile)
+COPY . /space
+
+# Install space-architect gem: prefer in-space checkout for a pinned version, fall back to RubyGems
+RUN if [ -d /space/repos/space-architect ]; then \
+      cd /space/repos/space-architect \
+   && rake build \
+   && gem install --no-document pkg/*.gem; \
+    else \
+      gem install --no-document space-architect; \
+    fi
+
+# Write entrypoint: sets git safe.directory, execs requested command or a login shell
+RUN echo '<%= entrypoint_b64 %>' | base64 -d > /entrypoint.sh \
+ && chmod +x /entrypoint.sh
+
+# Prepend gem-exec and payload bin dirs so login shells (bash --login) resolve architect/space/claude
+RUN printf 'export PATH="/usr/local/bundle/bin:/root/.local/bin:$PATH"\n' \
+ > /etc/profile.d/space-architect.sh
+<% if provision_scripts.any? -%>
+
+# Space-declared build-time provisioning (pack.provision)
+<% provision_scripts.each do |script| -%>
+RUN /space/<%= script %>
+<% end -%>
+<% end -%>
+
+WORKDIR /space
+
+ENTRYPOINT ["/entrypoint.sh"]
+CMD ["bash", "--login"]