space-architect 1.1.0

data/lib/space_architect/cli/architect.rb

@@ -0,0 +1,388 @@
+# frozen_string_literal: true
+
+module SpaceArchitect
+  module CLI
+    module Architect
+      class Init < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Scaffold architect mission memory in the current space"
+        argument :space, required: false, desc: "Space identifier (default: $PWD)"
+
+        def call(space: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              mission = ArchitectMission.new(space: sp)
+              path = mission.init!
+              terminal.say "Mission ready: #{terminal.path(path)}"
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
+      class New < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Scaffold the next iteration file (architecture/I<NN>-<iteration>.md)"
+        argument :iteration, required: true,  desc: "Iteration name (kebab-case)"
+        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+
+        def call(iteration:, space: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              mission = ArchitectMission.new(space: sp)
+              path = mission.new_iteration!(iteration)
+              terminal.say "Iteration scaffolded: #{terminal.path(path)}"
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
+      class Status < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Show architect mission state (read-only)"
+        argument :space, required: false, desc: "Space identifier (default: $PWD)"
+
+        def call(space: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              mission = ArchitectMission.new(space: sp)
+              info = mission.status
+              block = info[:block]
+
+              terminal.say "Mission status:     #{block['status'] || '(none)'}"
+              terminal.say "Current iteration:  #{block['current_iteration'] || '(none)'}"
+
+              iterations = block["iterations"] || []
+              if iterations.empty?
+                terminal.say "Iterations:        (none)"
+              else
+                rows = iterations.map do |s|
+                  nn = s["ordinal"] ? format("%02d", s["ordinal"]) : "-"
+                  lane_list = s["lanes"] || []
+                  lanes_str = lane_list.map do |l|
+                    h = l["harness"] || "claude-code"
+                    m = l["model"]   || Harness::CLAUDE_DEFAULT_MODEL
+                    eff = l["effort"] ? "·#{l['effort']}" : ""
+                    "#{l['name']}(#{l['repo']}·#{h}·#{m}#{eff})"
+                  end.join(", ")
+                  lanes = lane_list.any? { |l| l["variant"] } ? "variant: #{lanes_str}" : lanes_str
+                  lanes = "#{lanes} → winner: #{s['winner']}" if s["winner"]
+                  [nn, s["name"], s["freeze_sha"]&.[](0, 8) || "-", lanes, s["verdict"] || "-"]
+                end
+                terminal.say terminal.table(%w[II Iteration FreezeSHA Lanes Verdict], rows)
+              end
+
+              unless info[:iteration_files].empty?
+                terminal.say "Iteration files:   #{info[:iteration_files].join(', ')}"
+              end
+
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
+      class Freeze < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Freeze gates for an iteration"
+        argument :iteration, required: true, desc: "Iteration name"
+        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+
+        def call(iteration:, space: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              mission = ArchitectMission.new(space: sp)
+              sha = mission.freeze!(iteration)
+              terminal.say "Frozen #{iteration} at #{sha}"
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+      end
+
+      class Verify < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Post-flight mechanical checks for an iteration (reports only, no judgment)"
+        argument :iteration, required: true, desc: "Iteration name"
+        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+
+        def call(iteration:, space: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              mission = ArchitectMission.new(space: sp)
+              results = mission.verify(iteration)
+
+              if results.empty?
+                terminal.say "No lanes recorded for iteration '#{iteration}'"
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+                next
+              end
+
+              rows = results.flat_map do |r|
+                lane = r[:lane]
+                c = r[:checks]
+                [
+                  [lane, "(a) frozen sections untouched", pass_fail(c[:frozen_untouched])],
+                  [lane, "(b) no builder commits",        pass_fail(c[:no_builder_commits])],
+                  [lane, "(c) scratch report exists",     pass_fail(c[:report_exists])],
+                  [lane, "(d) in-bounds",                 pass_fail(c[:in_bounds])]
+                ]
+              end
+
+              terminal.say terminal.table(%w[Lane Check Result], rows)
+              CLI.record_outcome(Outcome.new(exit_code: 0))
+            end
+          end
+        end
+
+        private
+
+        def pass_fail(val)
+          case val
+          when true  then "PASS"
+          when false then "FAIL"
+          else            "N/A"
+          end
+        end
+      end
+
+      class Dispatch < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Dispatch a builder for a lane (streams to build/<id>-<lane>/run.jsonl)"
+        argument :iteration, required: true,  desc: "Iteration name"
+        argument :lane,      required: true,  desc: "Lane name"
+        argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+        option   :model,     default: nil,   desc: "Model to use (default: lane entry or claude-sonnet-4-6)"
+        option   :max_turns, default: "200", desc: "Max turns for the builder"
+        option   :harness,   default: nil,   desc: "Harness override (claude-code, opencode)"
+        option   :effort,    default: nil,   desc: "Reasoning effort override (opencode only; sets reasoningEffort in the model config)"
+
+        def call(iteration:, lane:, space: nil, model: nil,
+                 max_turns: "200", harness: nil, effort: nil, **opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            render(store.find(space)) do |sp|
+              mission = ArchitectMission.new(space: sp)
+              kwargs = { max_turns: max_turns.to_i }
+              kwargs[:model]   = model   if model
+              kwargs[:harness] = harness if harness
+              kwargs[:effort]  = effort  if effort
+              res = mission.dispatch(iteration, lane, **kwargs)
+              terminal.say "Run log: #{terminal.path(res[:run_log])}"
+              terminal.say "Report:  #{terminal.path(res[:report])}"
+              terminal.say "Builder exited with status #{res[:exit_code]}"
+              CLI.record_outcome(Outcome.new(exit_code: res[:exit_code]))
+            end
+          end
+        end
+      end
+
+      module Worktree
+        class Add < Dry::CLI::Command
+          include GlobalOptions
+          include Helpers
+
+          desc "Create a worktree for a lane"
+          argument :repo,      required: true, desc: "Repo name (under repos/)"
+          argument :iteration, required: true, desc: "Iteration name"
+          argument :lane,      required: true, desc: "Lane name"
+          option   :base,      default: nil,          desc: "Base ref (default: HEAD of repo)"
+          option   :harness,   default: "claude-code", desc: "Harness (claude-code, opencode)"
+          option   :model,     default: nil,           desc: "Model (required for opencode)"
+          option   :effort,    default: nil,           desc: "Reasoning effort (opencode only; sets reasoningEffort in the model config)"
+
+          def call(repo:, iteration:, lane:, base: nil, harness: "claude-code", model: nil, effort: nil, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find) do |sp|
+                mission = ArchitectMission.new(space: sp)
+                result = mission.worktree_add(repo, iteration, lane, base: base,
+                                             harness: harness, model: model, effort: effort)
+                terminal.say "Worktree: #{terminal.path(result[:worktree])}"
+                terminal.say "Base SHA: #{result[:base_sha]}"
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+
+        class Remove < Dry::CLI::Command
+          include GlobalOptions
+          include Helpers
+
+          desc "Remove a lane worktree"
+          argument :iteration, required: true, desc: "Iteration name"
+          argument :lane,      required: true, desc: "Lane name"
+
+          def call(iteration:, lane:, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find) do |sp|
+                mission = ArchitectMission.new(space: sp)
+                mission.worktree_remove(iteration, lane)
+                terminal.say "Removed worktree for #{iteration}/#{lane}"
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+
+        class List < Dry::CLI::Command
+          include GlobalOptions
+          include Helpers
+
+          desc "List active architect worktrees"
+
+          def call(**opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find) do |sp|
+                mission = ArchitectMission.new(space: sp)
+                worktrees = mission.worktree_list
+                if worktrees.empty?
+                  terminal.say "No active architect worktrees"
+                else
+                  worktrees.each { |wt| terminal.say wt }
+                end
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+      end
+
+      module Variant
+        class Add < Dry::CLI::Command
+          include GlobalOptions
+          include Helpers
+
+          desc "Create a variant set (competing lanes over one frozen spec)"
+          argument :repo,      required: true,  desc: "Repo name (under repos/)"
+          argument :iteration, required: true,  desc: "Iteration name"
+          argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+          option   :pairs,     required: true,  desc: "Comma-separated harness[:model] pairs (e.g. claude-code,opencode:fireworks-ai/accounts/fireworks/models/glm-5p2)"
+          option   :base,      default: nil,    desc: "Base ref (default: HEAD of repo)"
+          option   :prompt,    default: nil,    desc: "Prompt file to fan-out byte-identical to each variant"
+
+          def call(repo:, iteration:, space: nil, pairs:, base: nil, prompt: nil, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find(space)) do |sp|
+                parsed_pairs = pairs.to_s.split(",").map do |spec|
+                  harness, model = spec.split(":", 2)
+                  model = nil if model.nil? || model.empty?
+                  [harness, model]
+                end
+
+                mission = ArchitectMission.new(space: sp)
+                variants = mission.variant_add(repo, iteration, parsed_pairs, base: base, prompt: prompt)
+                variants.each do |v|
+                  terminal.say "#{v[:name]} · #{v[:harness]} · #{v[:model] || "(default)"} · #{terminal.path(v[:worktree])}"
+                end
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+
+        class Promote < Dry::CLI::Command
+          include GlobalOptions
+          include Helpers
+
+          desc "Promote one variant of a variant set as the winner"
+          argument :iteration, required: true,  desc: "Iteration name"
+          argument :winner,    required: true,  desc: "Variant lane name to promote (e.g. v02)"
+          argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+
+          def call(iteration:, winner:, space: nil, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find(space)) do |sp|
+                mission = ArchitectMission.new(space: sp)
+                result = mission.variant_promote(iteration, winner)
+                if result[:discarded].any?
+                  terminal.say "Promoted #{result[:winner]} (discarded: #{result[:discarded].join(', ')})"
+                else
+                  terminal.say "Promoted #{result[:winner]}"
+                end
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+
+        class Compare < Dry::CLI::Command
+          include GlobalOptions
+          include Helpers
+
+          desc "Compare variants of an iteration's variant set (read-only)"
+          argument :iteration, required: true,  desc: "Iteration name"
+          argument :space,     required: false, desc: "Space identifier (default: $PWD)"
+
+          def call(iteration:, space: nil, **opts)
+            setup_terminal(**opts.slice(:color, :colors))
+            handle_errors do
+              render(store.find(space)) do |sp|
+                mission = ArchitectMission.new(space: sp)
+                info = mission.variant_compare(iteration)
+
+                terminal.say "Variant comparison: #{iteration} (freeze #{info[:freeze_sha]&.[](0, 8) || "-"})"
+                terminal.say "Winner: #{info[:winner] || '(none)'}"
+                terminal.say ""
+                rows = info[:variants].map do |v|
+                  [
+                    v[:name],
+                    v[:harness],
+                    v[:model] || "(default)",
+                    v[:effort] || "-",
+                    v[:status] == "winner" ? "WINNER" : v[:status],
+                    v[:integration_branch] || "-",
+                    v[:base_sha]&.[](0, 8) || "-"
+                  ]
+                end
+                terminal.say terminal.table(%w[Variant Harness Model Effort Status Integration Base], rows)
+
+                CLI.record_outcome(Outcome.new(exit_code: 0))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+SpaceArchitect::CLI::Registry.register "init",   SpaceArchitect::CLI::Architect::Init
+SpaceArchitect::CLI::Registry.register "new",    SpaceArchitect::CLI::Architect::New
+SpaceArchitect::CLI::Registry.register "status", SpaceArchitect::CLI::Architect::Status
+SpaceArchitect::CLI::Registry.register "freeze", SpaceArchitect::CLI::Architect::Freeze
+SpaceArchitect::CLI::Registry.register "verify", SpaceArchitect::CLI::Architect::Verify
+SpaceArchitect::CLI::Registry.register "dispatch", SpaceArchitect::CLI::Architect::Dispatch
+SpaceArchitect::CLI::Registry.register "worktree" do |wt|
+  wt.register "add",    SpaceArchitect::CLI::Architect::Worktree::Add
+  wt.register "remove", SpaceArchitect::CLI::Architect::Worktree::Remove
+  wt.register "list",   SpaceArchitect::CLI::Architect::Worktree::List
+end
+SpaceArchitect::CLI::Registry.register "variant" do |v|
+  v.register "add",     SpaceArchitect::CLI::Architect::Variant::Add
+  v.register "promote", SpaceArchitect::CLI::Architect::Variant::Promote
+  v.register "compare", SpaceArchitect::CLI::Architect::Variant::Compare
+end

data/lib/space_architect/cli/config.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SpaceArchitect
+  module CLI
+    module Config
+      class Show < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        desc "Show current config"
+
+        def call(**opts)
+          setup_terminal(**opts.slice(:color, :colors))
+          handle_errors do
+            rows = SpaceArchitect::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 < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        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 < Dry::CLI::Command
+        include GlobalOptions
+        include Helpers
+
+        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
+end
+

data/lib/space_architect/cli/current.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SpaceArchitect
+  module CLI
+    class Current < Dry::CLI::Command
+      include GlobalOptions
+      include Helpers
+
+      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
+end
+

data/lib/space_architect/cli/helpers.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+module SpaceArchitect
+  module CLI
+    module Helpers
+      include Dry::Monads[:result]
+      def project_config
+        @project_config ||= SpaceArchitect::Config.load
+      end
+
+      def state
+        @state ||= SpaceArchitect::State.load
+      end
+
+      def store
+        @store ||= SpaceArchitect::SpaceStore.new(config: project_config, state: state)
+      end
+
+      def terminal
+        @terminal
+      end
+
+      def setup_terminal(color: "auto", colors: nil)
+        @terminal = 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 SpaceArchitect::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
+end

data/lib/space_architect/cli/init.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SpaceArchitect
+  module CLI
+    class Init < Dry::CLI::Command
+      include GlobalOptions
+      include Helpers
+
+      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 = SpaceArchitect::Config.new
+            @state = SpaceArchitect::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
+end
+

data/lib/space_architect/cli/list.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SpaceArchitect
+  module CLI
+    class List < Dry::CLI::Command
+      include GlobalOptions
+      include Helpers
+
+      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
+end
+