space-architect 8.0.0 → 9.0.0

data/lib/space_core/git_client.rb

@@ -1,49 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,56 +0,0 @@
-# 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

@@ -1,103 +0,0 @@
-# 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_architect?
-      space.path.join("repos/space-architect").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

@@ -1,89 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

data/lib/space_core/repo_resolver.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module Space::Core
-  class RepoResolver
-    SCP_LIKE_PATTERN = /\A(?:[^@\/]+@)?(?<provider>[^:\/]+):(?<path>.+)\z/
-    URL_PATTERN = %r{\A[A-Za-z][A-Za-z0-9+\-.]*://}
-
-    attr_reader :config
-
-    def initialize(config)
-      @config = config
-    end
-
-    def resolve(spec)
-      value = spec.to_s.strip
-      raise RepoResolutionError, "Repo cannot be blank" if value.empty?
-
-      if url_like?(value)
-        resolve_url(value)
-      elsif (match = value.match(SCP_LIKE_PATTERN))
-        reference_from_parts(
-          provider: match[:provider],
-          path_parts: split_repo_path(match[:path]),
-          clone_url: value,
-          source: value
-        )
-      else
-        resolve_shorthand(value)
-      end
-    end
-
-    private
-
-    def resolve_url(value)
-      uri = URI.parse(value)
-      provider = uri.host
-      path = uri.path.to_s.delete_prefix("/")
-      raise RepoResolutionError, "Could not determine provider from '#{value}'" if provider.to_s.empty?
-
-      reference_from_parts(
-        provider: provider,
-        path_parts: split_repo_path(path),
-        clone_url: value,
-        source: value
-      )
-    rescue URI::InvalidURIError
-      raise RepoResolutionError, "Could not parse repo URL '#{value}'"
-    end
-
-    def resolve_shorthand(value)
-      parts = split_repo_path(value)
-
-      if parts.length == 1
-        resolve_default_organization_repo(parts.first, value)
-      elsif provider_like?(parts.first) && parts.length >= 3
-        reference_from_parts(
-          provider: parts.first,
-          path_parts: parts[1..],
-          clone_url: nil,
-          source: value
-        )
-      else
-        resolve_default_provider_repo(parts, value)
-      end
-    end
-
-    def resolve_default_organization_repo(name, source)
-      provider = require_default_provider(source)
-      owner = config.default_organization
-      unless owner
-        raise RepoResolutionError,
-              "Repo '#{source}' needs an organization. Set one with: space config set default_organization ORG"
-      end
-
-      reference(provider:, owner:, name:, clone_url: nil, source:)
-    end
-
-    def resolve_default_provider_repo(parts, source)
-      provider = require_default_provider(source)
-      reference_from_parts(provider:, path_parts: parts, clone_url: nil, source:)
-    end
-
-    def reference_from_parts(provider:, path_parts:, clone_url:, source:)
-      if path_parts.length < 2
-        raise RepoResolutionError, "Repo '#{source}' must include an organization and repo name"
-      end
-
-      name = path_parts.last
-      owner = path_parts[0...-1].join("/")
-      reference(provider:, owner:, name:, clone_url:, source:)
-    end
-
-    def reference(provider:, owner:, name:, clone_url:, source:)
-      normalized_provider = normalize_provider(provider)
-      normalized_owner = normalize_path_part(owner)
-      normalized_name = normalize_repo_name(name)
-
-      RepoReference.new(
-        provider: normalized_provider,
-        owner: normalized_owner,
-        name: normalized_name,
-        clone_url: clone_url || clone_url_for(normalized_provider, normalized_owner, normalized_name),
-        source: source
-      )
-    end
-
-    def clone_url_for(provider, owner, name)
-      case config.git_clone_protocol
-      when "ssh"
-        "git@#{provider}:#{owner}/#{name}.git"
-      when "https"
-        "https://#{provider}/#{owner}/#{name}.git"
-      end
-    end
-
-    def split_repo_path(value)
-      normalized = value.to_s.strip.delete_prefix("/").delete_suffix("/")
-      normalized = normalized.delete_suffix(".git")
-      parts = normalized.split("/").reject(&:empty?)
-      raise RepoResolutionError, "Repo '#{value}' must include a repo name" if parts.empty?
-
-      parts
-    end
-
-    def require_default_provider(source)
-      config.default_provider || raise(
-        RepoResolutionError,
-        "Repo '#{source}' needs a provider. Set one with: space config set default_provider PROVIDER"
-      )
-    end
-
-    def normalize_provider(value)
-      normalized = value.to_s.strip
-      normalized = normalized.delete_prefix("https://")
-      normalized = normalized.delete_prefix("http://")
-      normalized = normalized.delete_prefix("ssh://")
-      normalized = normalized.delete_suffix("/")
-      raise RepoResolutionError, "Provider cannot be blank" if normalized.empty?
-
-      normalized
-    end
-
-    def normalize_path_part(value)
-      normalized = value.to_s.strip.delete_prefix("/").delete_suffix("/")
-      raise RepoResolutionError, "Organization cannot be blank" if normalized.empty?
-
-      normalized
-    end
-
-    def normalize_repo_name(value)
-      normalized = value.to_s.strip.delete_suffix(".git")
-      raise RepoResolutionError, "Repo name cannot be blank" if normalized.empty?
-
-      normalized
-    end
-
-    def url_like?(value)
-      value.match?(URL_PATTERN)
-    end
-
-    def provider_like?(value)
-      value.include?(".") || value.include?(":") || value == "localhost"
-    end
-  end
-end