space-architect 1.2.0 → 2.0.0.rc1

data/lib/space_architect/research/supervisor.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module Space::Architect
+  module Research
+    class Supervisor
+      DEFAULT_MODEL     = Harness::CLAUDE_DEFAULT_MODEL
+      DEFAULT_MAX_TURNS = 40
+
+      def initialize(space:, bin: nil)
+        @space    = space
+        @bin      = bin
+        @registry = Registry.new(space.path.join("build", "research", "registry.yaml"))
+      end
+
+      # Dispatch each prompt file as a detached read-only claude -p child.
+      # Returns array of Run objects (non-blocking).
+      def dispatch(prompts, model: DEFAULT_MODEL, max_turns: DEFAULT_MAX_TURNS)
+        prompts.map { |path| dispatch_one(Pathname.new(path), model: model, max_turns: max_turns) }
+      end
+
+      # Classify each registered run and return per-run state hashes.
+      def status
+        @registry.all.map do |run|
+          state = classify(run)
+          tail  = tail_lines(run.run_log_path, 5)
+          { run: run, state: state, tail: tail }
+        end
+      end
+
+      # Async mux: tail all runs to terminal. Returns :ok or :failed.
+      def wait(quiet: false, level: 1, thinking: false, jsonl: false, out: $stdout)
+        effective_level = quiet ? 0 : level
+        renderer = Renderer.new(level: effective_level, thinking: thinking, jsonl: jsonl)
+        runs = @registry.all
+        return :ok if runs.empty?
+
+        Mux.new(runs, renderer: renderer, out: out).run
+      end
+
+      private
+
+      def dispatch_one(path, model:, max_turns:)
+        id    = derive_id(path)
+        topic = id.sub(/\A\d+-/, "")
+        dir   = @space.path.join("build", "research", id)
+        FileUtils.mkdir_p(dir)
+
+        prompt_path  = dir.join("prompt.md")
+        run_log_path = dir.join("run.jsonl")
+        report_path  = dir.join("report.md")
+
+        FileUtils.cp(path.to_s, prompt_path.to_s)
+
+        harness = Harness::ClaudeCodeHarness.new(
+          model:            model,
+          max_turns:        max_turns,
+          bin:              @bin,
+          allowed_tools:    READONLY_TOOLS,
+          disallowed_tools: ""
+        )
+
+        pid = harness.run_detached(
+          prompt_path:  prompt_path,
+          run_log_path: run_log_path,
+          chdir:        @space.path
+        )
+
+        run = Run.new(
+          id:            id,
+          topic:         topic,
+          pid:           pid,
+          dir:           dir,
+          prompt_path:   prompt_path,
+          run_log_path:  run_log_path,
+          report_path:   report_path,
+          model:         model,
+          dispatched_at: Time.now
+        )
+        @registry.add(run)
+        run
+      end
+
+      def derive_id(path)
+        File.basename(path.to_s).sub(/\.prompt\.md\z/, "").sub(/\.md\z/, "")
+      end
+
+      def classify(run)
+        content = File.exist?(run.run_log_path.to_s) ? File.read(run.run_log_path.to_s) : ""
+        events  = content.lines.filter_map { |l| JSON.parse(l.chomp) rescue nil }
+        terminal = events.find { |e| e["type"] == "result" }
+
+        return :complete if terminal && !terminal["is_error"]
+        return :failed   if terminal && terminal["is_error"]
+
+        pid_alive = begin; Process.kill(0, run.pid); true; rescue Errno::ESRCH, Errno::EPERM; false; end
+        pid_alive ? :running : :failed
+      end
+
+      def tail_lines(path, n)
+        return [] unless File.exist?(path.to_s)
+        File.readlines(path.to_s).last(n).map(&:chomp)
+      end
+    end
+  end
+end

data/lib/space_architect/research.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Space::Architect
+  module Research
+    READONLY_TOOLS = "Read,Grep,Glob,WebSearch,WebFetch"
+  end
+end
+
+require_relative "research/run"
+require_relative "research/registry"
+require_relative "research/renderer"
+require_relative "research/mux"
+require_relative "research/supervisor"

data/lib/space_architect/run_creator.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "async/http/client"
+require "async/http/endpoint"
+require "json"
+
+module Space::Architect
+  class RunCreator
+    def initialize(host, token, client: nil)
+      @host   = host.chomp("/")
+      @token  = token
+      @client = client
+    end
+
+    # POSTs to /runs and returns the integer run id.
+    # Raises Space::Core::Error on any failure — never returns nil.
+    def create
+      Sync do
+        if @client
+          response = @client.post("/runs", headers: headers, body: nil)
+          parse_response(response)
+        else
+          Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(@host)) do |c|
+            response = c.post("/runs", headers: headers, body: nil)
+            parse_response(response)
+          end
+        end
+      end
+    end
+
+    private
+
+    def headers
+      [
+        ["authorization", "Bearer #{@token}"],
+        ["content-type",  "application/json"]
+      ]
+    end
+
+    def parse_response(response)
+      status = response.status
+      body   = response.read || ""
+      raise Space::Core::Error, "POST /runs failed (#{status}): #{body[0, 200]}" unless status == 201
+
+      parsed = JSON.parse(body)
+      id     = parsed["id"]
+      raise Space::Core::Error, "POST /runs: missing or non-integer id in response: #{body[0, 200]}" \
+        unless id.is_a?(Integer)
+
+      id
+    end
+  end
+end

data/lib/space_architect/skill_installer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module Space
+  module Architect
+    module SkillInstaller
+      PROVIDERS = %w[claude codex opencode pi].freeze
+
+      class << self
+        def source_root
+          Pathname.new(__dir__).parent.parent.join("skill")
+        end
+
+        def dest_root(provider, project:, env:, cwd: Dir.pwd)
+          case provider.to_s
+          when "claude"
+            base = project ? Pathname.new(cwd) : Pathname.new(Space::Core::XDG.home(env: env))
+            base.join(".claude", "skills")
+          when "codex"
+            base = project ? Pathname.new(cwd) : Pathname.new(Space::Core::XDG.home(env: env))
+            base.join(".agents", "skills")
+          when "opencode"
+            project ? Pathname.new(cwd).join(".opencode", "skills") : Space::Core::XDG.config_home(env: env).join("skills")
+          when "pi"
+            base = project ? Pathname.new(cwd) : Pathname.new(pi_agent_dir(env: env))
+            base.join("skills")
+          else
+            raise Space::Core::Error, "Unknown provider '#{provider}'. Expected one of: #{PROVIDERS.join(', ')}"
+          end
+        end
+
+        def install(provider, project:, force:, env:, cwd: Dir.pwd, dry_run: false)
+          validate_provider!(provider)
+          dest = dest_root(provider, project: project, env: env, cwd: cwd)
+          results = []
+
+          source_skills.each do |skill_dir|
+            name = skill_dir.basename.to_s
+            skill_dest = dest.join(name)
+            results << install_skill(skill_dir, skill_dest, force: force, dry_run: dry_run)
+          end
+
+          { dest_root: dest, skills: results, dry_run: dry_run }
+        end
+
+        def source_skills
+          source_root.children.select(&:directory?)
+        end
+
+        private
+
+        def validate_provider!(provider)
+          return if PROVIDERS.include?(provider.to_s)
+
+          raise Space::Core::Error, "Unknown provider '#{provider}'. Expected one of: #{PROVIDERS.join(', ')}"
+        end
+
+        def pi_agent_dir(env:)
+          Pathname.new(env.fetch("PI_CODING_AGENT_DIR", File.join(Space::Core::XDG.home(env: env), ".pi", "agent")))
+        end
+
+        def install_skill(source, dest, force:, dry_run:)
+          name = source.basename.to_s
+
+          if dest.exist?
+            if same_content?(source, dest)
+              return { name: name, action: :unchanged, path: dest }
+            end
+
+            unless force
+              return { name: name, action: :conflict, path: dest } if dry_run
+
+              raise Space::Core::Error,
+                "Refusing to overwrite existing skill at #{dest}. Re-run with --force."
+            end
+
+            unless dry_run
+              FileUtils.rm_rf(dest)
+              FileUtils.cp_r(source, dest)
+            end
+            { name: name, action: dry_run ? :would_update : :updated, path: dest }
+          else
+            unless dry_run
+              FileUtils.mkdir_p(dest.parent)
+              FileUtils.cp_r(source, dest)
+            end
+            { name: name, action: dry_run ? :would_install : :installed, path: dest }
+          end
+        end
+
+        def same_content?(source, dest)
+          return false unless dest.directory?
+
+          source_files = Dir.glob("#{source}/**/*").reject { |f| File.directory?(f) }
+          dest_files = Dir.glob("#{dest}/**/*").reject { |f| File.directory?(f) }
+
+          return false if source_files.length != dest_files.length
+
+          source_files.sort.zip(dest_files.sort).all? do |sf, df|
+            rel = sf.sub("#{source}/", "")
+            df.end_with?(rel) && File.read(sf) == File.read(df)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/space_architect.rb

@@ -1,26 +1,12 @@
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path("../vendor/repo-tender/lib", __dir__)
-require "space_architect/pristine"
+require "space_core"
+require "space_src"
 
-require_relative "space_architect/version"
-require_relative "space_architect/errors"
-require_relative "space_architect/warnings"
-SpaceArchitect::Warnings.disable_experimental!
-require_relative "space_architect/atomic_write"
-require_relative "space_architect/xdg"
-require_relative "space_architect/config"
-require_relative "space_architect/state"
-require_relative "space_architect/slugger"
-require_relative "space_architect/space"
-require_relative "space_architect/repo_reference"
-require_relative "space_architect/repo_resolver"
-require_relative "space_architect/git_client"
-require_relative "space_architect/mise_client"
-require_relative "space_architect/space_store"
-require_relative "space_architect/shell_integration"
-require_relative "space_architect/terminal"
 require_relative "space_architect/harness"
+require_relative "space_architect/run_creator"
 require_relative "space_architect/dispatcher"
 require_relative "space_architect/architect_mission"
+require_relative "space_architect/skill_installer"
+require_relative "space_architect/research"
 require_relative "space_architect/cli"

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

@@ -2,7 +2,7 @@
 
 require "fileutils"
 
-module SpaceArchitect
+module Space::Core
   module AtomicWrite
     module_function
 

data/lib/space_core/cli/base_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+
+module Space::Core::CLI
+  # Base for every space/architect command. dry-cli (>= 0.7.0) copies a
+  # superclass's options to its subclasses, so the global colour options are
+  # declared once here and inherited everywhere instead of being mixed in per
+  # command. Helpers (terminal/store/render) ride along by inheritance too.
+  #
+  # The `src` binary has its own output-mode system (--plain/--json) and does
+  # NOT inherit from this base.
+  class BaseCommand < Dry::CLI::Command
+    include Helpers
+
+    option :color,  type: :string, default: "auto", desc: "Color output: auto, always, never"
+    option :colors, type: :string, desc: "Alias for --color"
+  end
+end

data/lib/space_core/cli/config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+module Config
+  class Show < BaseCommand
+    desc "Show current config"
+
+    def call(**opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        rows = Space::Core::Config::EDITABLE_KEYS.map do |key|
+          value = project_config.data[key]
+          [key, value.nil? ? "" : value.to_s]
+        end
+        terminal.say terminal.table(%w[Key Value], rows)
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+
+  class ConfigPath < BaseCommand
+    desc "Print the config file path"
+
+    def call(**opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        terminal.say terminal.path(project_config.path)
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+
+  class Set < BaseCommand
+    desc "Set a config key"
+    argument :key, required: true, desc: "Config key"
+    argument :value, required: true, desc: "Config value"
+
+    def call(key:, value:, **opts)
+      setup_terminal(**opts.slice(:color, :colors))
+      handle_errors do
+        project_config.set(key, value)
+        stored = project_config.data[key]
+        terminal.success "Set #{key}=#{stored.nil? ? '' : stored.to_s}"
+        CLI.record_outcome(Outcome.new(exit_code: 0))
+      end
+    end
+  end
+end
+end

data/lib/space_core/cli/current.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Space::Core::CLI
+class Current < BaseCommand
+  desc "Show the current space"
+
+  def call(**opts)
+    setup_terminal(**opts.slice(:color, :colors))
+    render(store.find) do |space|
+      terminal.say space.id.to_s
+      terminal.say terminal.path(space.path)
+      CLI.record_outcome(Outcome.new(exit_code: 0))
+    end
+  end
+end
+end

data/lib/space_core/cli/help.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "pastel"
+
+module Space::Core::CLI
+  # Colourful replacement for dry-cli's plain `Usage` listing — the "global
+  # help" shown by `space`, `architect`, and every bare namespace (`space repo`,
+  # `worktree`, ...). Per-command help still flows through dry-cli's Banner,
+  # whose content we like; only the listing is reskinned.
+  #
+  # We reopen Dry::CLI::Usage.call (below) to delegate here, so BOTH the
+  # intercepted top-level help and dry-cli's own bare-namespace path get the
+  # same treatment from one place. Colour follows CLI.help_pastel, set once per
+  # invocation from the output stream's tty-ness and --color, so piped and test
+  # output stay plain. The `src` binary never loads space_core, so its own plain
+  # Usage is untouched.
+  module Help
+    TAGLINE = "date-prefixed workspaces; repos provisioned on fibers at copy-on-write speed"
+
+    module_function
+
+    def call(result, pastel: CLI.help_pastel)
+      rows  = listing(result)
+      width = rows.map { |label, _| label.length }.max || 0
+
+      lines = rows.map do |label, description|
+        painted = pastel.cyan(label.ljust(width))
+        description ? "  #{painted}   #{pastel.dim("# #{description}")}" : "  #{painted}"
+      end
+
+      [header(result, pastel), pastel.bold("Commands:"), *lines, footer(result, pastel)]
+        .compact.join("\n")
+    end
+
+    # The richer header only makes sense at the true root (`space` / `architect`),
+    # not on every sub-namespace listing.
+    def header(result, pastel)
+      return unless result.names.empty?
+
+      "#{pastel.bold.cyan("space-architect")} #{pastel.dim(Space::Core::VERSION)} " \
+        "#{pastel.dim("— #{TAGLINE}")}\n"
+    end
+
+    def footer(result, pastel)
+      "\n#{pastel.dim("Run `#{program_prefix(result)} <command> --help` for details on a command.")}"
+    end
+
+    # "space" at the root, "space repo" inside a namespace. The `space`/`architect`
+    # binaries inject their name into ARGV, so $PROGRAM_NAME and the leading
+    # namespace segment can collide ("space space ..."); drop the duplicate.
+    def program_prefix(result)
+      prog  = File.basename($PROGRAM_NAME)
+      names = result.names.dup
+      names.shift if names.first == prog
+      [prog, *names].join(" ")
+    end
+
+    # [[label_with_banner, description_or_nil], ...] sorted by command name.
+    def listing(result)
+      result.children.sort_by { |name, _| name }.filter_map do |name, node|
+        next if node.hidden
+
+        [label(result, name, node), description(node)]
+      end
+    end
+
+    def label(result, name, node)
+      "#{program_prefix(result)} #{name}#{banner(node)}"
+    end
+
+    def banner(node)
+      if node.command && node.leaf? && node.children?
+        " [ARGUMENT|SUBCOMMAND]"
+      elsif node.leaf?
+        arguments(node.command)
+      else
+        " [SUBCOMMAND]"
+      end
+    end
+
+    def arguments(command)
+      return "" unless command.respond_to?(:required_arguments)
+
+      names = command.required_arguments.map { |arg| arg.name.to_s.upcase }
+      names += command.optional_arguments.map { |arg| "[#{arg.name.to_s.upcase}]" }
+      names.empty? ? "" : " #{names.join(" ")}"
+    end
+
+    def description(node)
+      return unless node.leaf? && node.command.respond_to?(:description)
+
+      node.command.description
+    end
+  end
+end
+
+# Route dry-cli's plain namespace/root listing through our colourful renderer.
+# We replace Usage.call wholesale and depend only on the LookupResult/Node API
+# (children, command, leaf?/children?/hidden, names) rather than copying Usage's
+# internals — see notes/ruby-cli-gems-report.md.
+module Dry
+  class CLI
+    module Usage
+      def self.call(result)
+        Space::Core::CLI::Help.call(result)
+      end
+    end
+  end
+end

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