space-cadet 9.0.0

data/lib/space_core/config.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Space::Core
+  class Config
+    DEFAULT_DATA = {
+      "version" => 1,
+      "base_dir" => "~/architect",
+      "default_provider" => "github.com",
+      "default_organization" => nil,
+      "git_clone_protocol" => "ssh"
+    }.freeze
+    EDITABLE_KEYS = %w[
+      base_dir
+      spaces_dir
+      src_dir
+      default_provider
+      default_organization
+      git_clone_protocol
+    ].freeze
+    VALID_GIT_CLONE_PROTOCOLS = %w[ssh https].freeze
+
+    attr_reader :path, :data, :env
+
+    def self.default_path(env: ENV)
+      XDG.config_home(env: env).join("space-cadet", "config.yml")
+    end
+
+    def self.load(env: ENV, path: default_path(env: env))
+      new(env:, path:).load
+    end
+
+    def initialize(env: ENV, path: self.class.default_path(env: env), data: nil)
+      @path = Pathname.new(path)
+      @env = env
+      @data = data ? DEFAULT_DATA.merge(stringify_keys(data)) : DEFAULT_DATA.dup
+    end
+
+    def load
+      @data = if path.exist?
+                parsed = YAML.safe_load(path.read, aliases: false) || {}
+                unless parsed.is_a?(Hash)
+                  raise Error, "Config file must contain a YAML mapping: #{path}"
+                end
+
+                DEFAULT_DATA.merge(stringify_keys(parsed))
+              else
+                DEFAULT_DATA.dup
+              end
+      self
+    end
+
+    def ensure_exists!
+      save unless path.exist?
+      self
+    end
+
+    def save
+      AtomicWrite.write(path, YAML.dump(data))
+      self
+    end
+
+    def base_dir
+      Pathname.new(XDG.expand_user(data.fetch("base_dir"), env: env))
+    end
+
+    def spaces_dir
+      value = normalized_value(data["spaces_dir"])
+      return base_dir.join("spaces") unless value
+
+      Pathname.new(XDG.expand_user(value, env: env))
+    end
+
+    def src_dir
+      return base_dir.join("src") unless data.key?("src_dir")
+
+      value = normalized_value(data["src_dir"])
+      return nil unless value
+
+      Pathname.new(XDG.expand_user(value, env: env))
+    end
+
+    def default_provider
+      normalize_provider(data["default_provider"])
+    end
+
+    def default_organization
+      normalized_value(data["default_organization"])
+    end
+
+    def git_clone_protocol
+      protocol = normalized_value(data["git_clone_protocol"]) || "ssh"
+      unless VALID_GIT_CLONE_PROTOCOLS.include?(protocol)
+        raise Error, "Invalid git_clone_protocol '#{protocol}'. Expected one of: #{VALID_GIT_CLONE_PROTOCOLS.join(', ')}"
+      end
+
+      protocol
+    end
+
+    def set(key, value)
+      normalized_key = key.to_s
+      unless EDITABLE_KEYS.include?(normalized_key)
+        raise InvalidConfigKeyError, "Unknown config key '#{key}'. Expected one of: #{EDITABLE_KEYS.join(', ')}"
+      end
+
+      data[normalized_key] = normalize_config_value(normalized_key, value)
+      save
+    end
+
+    private
+
+    def normalize_config_value(key, value)
+      case key
+      when "default_provider"
+        normalize_provider(value)
+      when "default_organization"
+        normalized_value(value)
+      when "git_clone_protocol"
+        protocol = normalized_value(value)
+        unless VALID_GIT_CLONE_PROTOCOLS.include?(protocol)
+          raise Error, "Invalid git_clone_protocol '#{value}'. Expected one of: #{VALID_GIT_CLONE_PROTOCOLS.join(', ')}"
+        end
+
+        protocol
+      else
+        value
+      end
+    end
+
+    def normalize_provider(value)
+      normalized = normalized_value(value)
+      return nil unless normalized
+
+      normalized
+        .delete_prefix("https://")
+        .delete_prefix("http://")
+        .delete_prefix("ssh://")
+        .delete_suffix("/")
+    end
+
+    def normalized_value(value)
+      normalized = value.to_s.strip
+      normalized.empty? ? nil : normalized
+    end
+
+    def stringify_keys(hash)
+      hash.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
+    end
+  end
+end

data/lib/space_core/errors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Space::Core
+  class Error < StandardError; end
+  class NotFoundError < Error; end
+  class AmbiguousSpaceError < Error; end
+  class InvalidStatusError < Error; end
+  class CurrentSpaceMissingError < Error; end
+  class InvalidConfigKeyError < Error; end
+  class RepoResolutionError < Error; end
+  class RepoExistsError < Error; end
+  class GitError < Error; end
+  class MiseError < Error; end
+end

data/lib/space_core/git_client.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "async/process"
+require "pathname"
+require "tempfile"
+
+module Space::Core
+  class GitClient
+    def init(path)
+      path = Pathname.new(path)
+      stdout, stderr, status = capture("git", "-C", path.to_s, "init")
+      return true if status.success?
+
+      output = [stdout, stderr].reject(&:empty?).join("\n").strip
+      message = "git init failed for #{path}"
+      message = "#{message}: #{output}" unless output.empty?
+      raise GitError, message
+    end
+
+    # Best-effort: a missing git identity (user.name/user.email) must not abort
+    # space creation. Returns false on failure, leaving the repo initialized but
+    # uncommitted.
+    def commit_all(path, message)
+      path = Pathname.new(path)
+      _, _, add_status = capture("git", "-C", path.to_s, "add", "-A")
+      return false unless add_status.success?
+
+      _, _, commit_status = capture("git", "-C", path.to_s, "commit", "-m", message)
+      commit_status.success?
+    end
+
+    private
+
+    def capture(*command)
+      stdout = Tempfile.new("project-spaces-git-stdout")
+      stderr = Tempfile.new("project-spaces-git-stderr")
+      status = Async::Process.spawn(*command, out: stdout, err: stderr)
+
+      stdout.rewind
+      stderr.rewind
+      [stdout.read, stderr.read, status]
+    ensure
+      stdout&.close!
+      stderr&.close!
+    end
+
+  end
+end

data/lib/space_core/mise_client.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "async/process"
+require "pathname"
+require "tempfile"
+
+module Space::Core
+  class MiseClient
+    def trust(path)
+      path = Pathname.new(path)
+      stdout, stderr, status = capture("mise", "trust", "--yes", "--quiet", "--cd", path.to_s)
+      return true if status.success?
+
+      output = [stdout, stderr].reject(&:empty?).join("\n").strip
+      message = "mise trust failed for #{path}"
+      message = "#{message}: #{output}" unless output.empty?
+      raise MiseError, message
+    rescue Errno::ENOENT
+      raise MiseError, "mise executable not found; install mise or make sure it is on PATH"
+    end
+
+    private
+
+    def capture(*command)
+      stdout = Tempfile.new("project-spaces-mise-stdout")
+      stderr = Tempfile.new("project-spaces-mise-stderr")
+      status = Async::Process.spawn(*command, out: stdout, err: stderr)
+
+      stdout.rewind
+      stderr.rewind
+      [stdout.read, stderr.read, status]
+    ensure
+      stdout&.close!
+      stderr&.close!
+    end
+  end
+end

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,103 @@
+# 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 local_space_cadet?
+      space.path.join("repos/space-cadet").directory?
+    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,89 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/monads"
+
+module Space::Core
+  class OciRunner
+    include Dry::Monads[:result]
+
+    # Always-forwarded substrate auth (the in-image architect/claude reach for these).
+    # Payload-specific vars are declared per-space via `run.env:` or the --env flag.
+    AUTH_ENV = %w[ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_BASE_URL].freeze
+
+    def initialize(space:, env: ENV.to_h, interactive: true, env_vars: [])
+      @space = space
+      @env = env
+      @interactive = interactive
+      @env_vars = (space.run_env + Array(env_vars)).map(&:to_s)
+    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"] : []),
+        *env_flags,
+        *mount_flags,
+        image,
+        *extra
+      ]
+      Success(argv)
+    end
+
+    # Explicitly-requested vars (run.env: + --env) that are unset/empty in the host
+    # env, so the caller can warn — silence here would let a missing key fail opaquely
+    # inside the guest. AUTH_ENV is opportunistic and intentionally excluded.
+    def missing_env
+      @env_vars.uniq.reject { |var| present?(var) }
+    end
+
+    private
+
+    attr_reader :space, :env, :interactive
+
+    # Bare `-e VAR` passthrough (no =value on the command line, so the secret never
+    # lands in argv/ps): substrate auth first, then the space's declared payload vars.
+    def env_flags
+      (AUTH_ENV + @env_vars).uniq.each_with_object([]) do |var, flags|
+        flags.push("-e", var) if present?(var)
+      end
+    end
+
+    def present?(var)
+      val = env[var]
+      val && !val.empty?
+    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_core/paths.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Space::Core
+  module Paths
+    # paths:exempt-file - the shared module itself — this is the one home the guard defends
+    module_function
+
+    # Flags for matching a changed path against a lane's touch_set globs.
+    # PATHNAME keeps a single `*` from crossing `/`; EXTGLOB enables `{a,b}`;
+    # DOTMATCH lets a glob reach dotfile segments, so a `dir/**` touch set covers
+    # `dir/.github/workflows/ci.yml` — the standard deliverable for a lane preparing
+    # a directory to become a repo root.
+    TOUCH_FNM = File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
+
+    # Every path beneath root, at every depth: files, directories, dotfiles, and
+    # dot-directory contents all included. `File::FNM_DOTMATCH` is what makes
+    # dotfiles visible to `Dir.glob`, but it also emits a bogus `root/.`
+    # self-entry — that trap is absorbed here so no callsite has to know about it.
+    # Returns Array<String> — Dir.glob's native return shape.
+    def content_tree(root)
+      Dir.glob(File.join(root.to_s, "**", "*"), File::FNM_DOTMATCH).reject { |p| File.basename(p) == "." }
+    end
+
+    # The direct children of a fixed-depth structured directory layout (one
+    # entry per iteration/skill/lane/space) where a leading dot never names a
+    # real layout member — only tooling junk (.git, .DS_Store). Excludes them.
+    # Returns Array<Pathname> — Pathname#children's native return shape.
+    def layout_children(dir)
+      Pathname.new(dir).children.reject { |c| c.basename.to_s.start_with?(".") }
+    end
+
+    # Does a single touch_set glob match path? A trailing `dir/**` is matched
+    # twice: bare (PATHNAME stops it at direct children) and as `dir/**/*`,
+    # whose whole-component `**/` does cross `/`.
+    def touch_match?(glob, path)
+      File.fnmatch(glob, path, TOUCH_FNM) ||
+        (glob.end_with?("/**") && File.fnmatch("#{glob}/*", path, TOUCH_FNM))
+    end
+
+    def contract(path, env: ENV)
+      value = path.to_s
+      home  = XDG.home(env: env)
+      [home, realpath_or_nil(home)].compact.uniq.each do |h|
+        return "~"  if value == h
+        return "~#{value.delete_prefix(h)}" if value.start_with?("#{h}/")
+      end
+      value
+    end
+
+    def realpath_or_nil(path)
+      File.realpath(path)
+    rescue SystemCallError
+      nil
+    end
+  end
+end

data/lib/space_core/repo_reference.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Space::Core
+  RepoReference = Data.define(:provider, :owner, :name, :clone_url, :source) do
+    def full_name
+      "#{provider}/#{owner}/#{name}"
+    end
+
+    def directory_name
+      name
+    end
+
+    def src_path(root)
+      Pathname.new(root).join(provider, owner, name)
+    end
+  end
+end