space-architect 1.1.0

data/lib/space_architect/config.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module SpaceArchitect
+  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-architect", "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_architect/dispatcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "harness"
+
+module SpaceArchitect
+  # Thin backward-compat wrapper around Harness::ClaudeCodeHarness.
+  # Existing callers that construct Dispatcher.new(...).run(...) continue to work byte-for-byte.
+  class Dispatcher
+    # Keep constants here so any code referencing Dispatcher::ALLOWED_TOOLS still works.
+    ALLOWED_TOOLS    = Harness::ClaudeCodeHarness::ALLOWED_TOOLS
+    DISALLOWED_TOOLS = Harness::ClaudeCodeHarness::DISALLOWED_TOOLS
+
+    def initialize(model: "claude-sonnet-4-6", max_turns: 200, claude_bin: nil)
+      @harness = Harness::ClaudeCodeHarness.new(model: model, max_turns: max_turns, bin: claude_bin)
+    end
+
+    def run(prompt_path:, run_log_path:, chdir:)
+      @harness.run(prompt_path: prompt_path, run_log_path: run_log_path, chdir: chdir)
+    end
+  end
+end

data/lib/space_architect/errors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SpaceArchitect
+  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_architect/git_client.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "async/process"
+require "pathname"
+require "tempfile"
+
+module SpaceArchitect
+  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_architect/harness.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "async/process"
+require "json"
+require "pathname"
+
+module SpaceArchitect
+  module Harness
+    CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6"
+
+    # Factory keyed by harness name.
+    # For opencode: config_dir is required (build/<id>-<lane> dir outside the worktree).
+    def self.for(name, model:, max_turns:, bin: nil, config_dir: nil, effort: nil)
+      case name.to_s
+      when "claude-code"
+        if effort
+          raise Error,
+            "effort is opencode-only (sets opencode reasoningEffort) — " \
+            "claude-code effort is set via the prompt"
+        end
+        ClaudeCodeHarness.new(model: model, max_turns: max_turns, bin: bin)
+      when "opencode"
+        if model == CLAUDE_DEFAULT_MODEL
+          raise Error,
+            "Pass --model when using --harness opencode (the claude-sonnet-4-6 default " \
+            "is a Claude model ID and will not work with opencode — " \
+            "try e.g. fireworks-ai/accounts/fireworks/models/glm-5p2)"
+        end
+        raise Error, "config_dir is required for opencode harness" unless config_dir
+        OpenCodeHarness.new(model: model, max_turns: max_turns, bin: bin, config_dir: config_dir, effort: effort)
+      else
+        raise Error, "Unknown harness '#{name}' — valid values: claude-code, opencode"
+      end
+    end
+
+    class ClaudeCodeHarness
+      ALLOWED_TOOLS    = "Read,Edit,Write,Grep,Glob,Bash,WebSearch,WebFetch"
+      DISALLOWED_TOOLS = [
+        "Bash(git commit:*)", "Bash(git push:*)", "Bash(git reset:*)",
+        "Bash(git merge:*)",  "Bash(git rebase:*)", "Bash(git checkout:*)",
+        "Bash(git branch:*)"
+      ].join(",")
+
+      def initialize(model:, max_turns:, bin: nil)
+        @model     = model
+        @max_turns = max_turns
+        @bin       = bin || ENV.fetch("ARCHITECT_CLAUDE_BIN", "claude")
+      end
+
+      def run(prompt_path:, run_log_path:, chdir:)
+        prompt_path  = Pathname.new(prompt_path)
+        run_log_path = Pathname.new(run_log_path)
+
+        File.open(prompt_path, "r") do |prompt_io|
+          File.open(run_log_path, "w") do |log|
+            status = Sync do
+              Async::Process.spawn(*argv, chdir: chdir.to_s, in: prompt_io, out: log, err: log)
+            end
+            status.exitstatus
+          end
+        end
+      end
+
+      private
+
+      def argv
+        [
+          @bin, "-p",
+          "--model", @model,
+          "--permission-mode", "acceptEdits",
+          "--allowedTools", ALLOWED_TOOLS,
+          "--disallowedTools", DISALLOWED_TOOLS,
+          "--output-format", "stream-json",
+          "--verbose",
+          "--max-turns", @max_turns.to_s
+        ]
+      end
+    end
+
+    class OpenCodeHarness
+      def initialize(model:, max_turns:, bin: nil, config_dir:, effort: nil)
+        @model      = model
+        @max_turns  = max_turns
+        @bin        = bin || ENV.fetch("ARCHITECT_OPENCODE_BIN", "opencode")
+        @config_dir = Pathname.new(config_dir)
+        @effort     = effort
+      end
+
+      # Returns the agent config hash (deterministic, unit-testable).
+      def builder_config
+        cfg = {
+          "agent" => {
+            "builder" => {
+              "steps" => @max_turns,
+              "permission" => {
+                "bash" => {
+                  "git commit *"   => "deny",
+                  "git push *"     => "deny",
+                  "git reset *"    => "deny",
+                  "git rebase *"   => "deny",
+                  "git checkout *" => "deny",
+                  "*"              => "allow"
+                }
+              }
+            }
+          }
+        }
+        cfg.merge!(reasoning_provider_config) if @effort
+        cfg
+      end
+
+      def run(prompt_path:, run_log_path:, chdir:)
+        prompt_path  = Pathname.new(prompt_path)
+        run_log_path = Pathname.new(run_log_path)
+        config_path  = write_config
+
+        env = {
+          "OPENCODE_CONFIG"                 => config_path.to_s,
+          "OPENCODE_DISABLE_PROJECT_CONFIG" => "1"
+        }
+
+        File.open(prompt_path, "r") do |prompt_io|
+          File.open(run_log_path, "w") do |log|
+            status = Sync do
+              Async::Process.spawn(env, *argv(chdir),
+                                   chdir: chdir.to_s, in: prompt_io, out: log, err: log)
+            end
+            status.exitstatus
+          end
+        end
+      end
+
+      private
+
+      def reasoning_provider_config
+        provider, model_id = @model.split("/", 2)
+        {
+          "provider" => {
+            provider => {
+              "models" => {
+                model_id => { "options" => { "reasoningEffort" => @effort } }
+              }
+            }
+          }
+        }
+      end
+
+      def write_config
+        path = @config_dir.join("opencode.json")
+        path.write(JSON.generate(builder_config))
+        path
+      end
+
+      # --dir sets the working directory for opencode's tooling layer.
+      def argv(chdir)
+        args = [
+          @bin, "run",
+          "--format", "json",
+          "--model", @model,
+          "--dangerously-skip-permissions",
+          "--agent", "builder",
+          "--dir", chdir.to_s
+        ]
+        args
+      end
+    end
+  end
+end

data/lib/space_architect/mise_client.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "async/process"
+require "pathname"
+require "tempfile"
+
+module SpaceArchitect
+  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_architect/repo_reference.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module SpaceArchitect
+  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_architect/repo_resolver.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module SpaceArchitect
+  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