space-architect 8.0.0 → 9.1.0

data/lib/space_core/space.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "pathname"
-require "time"
-
-module Space::Core
-  class Space
-    METADATA_FILE = "space.yaml"
-    VALID_STATUSES = %w[active paused done archived].freeze
-
-    # Canonical space.yaml shape: registry under `project:` (renamed from the
-    # pre-2.0 `architect:` key). Bumped from 1 in the release that did the
-    # rename, since that release shipped no read-side alias for it.
-    SCHEMA_VERSION = 2
-
-    attr_reader :path, :data
-
-    def self.load(path)
-      metadata_path = Pathname.new(path).join(METADATA_FILE)
-      raise NotFoundError, "No space metadata found at #{metadata_path}" unless metadata_path.exist?
-
-      parsed = YAML.safe_load(metadata_path.read, aliases: false) || {}
-      raise Error, "Space metadata must contain a YAML mapping: #{metadata_path}" unless parsed.is_a?(Hash)
-
-      data = stringify_keys(parsed)
-      normalize_schema!(data, metadata_path)
-      new(Pathname.new(path), data)
-    end
-
-    def self.stringify_keys(hash)
-      hash.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
-    end
-
-    # Normalizes a parsed space.yaml hash to canonical schema v2, in place:
-    #   - future version (> SCHEMA_VERSION) → raise, refuse to misread it.
-    #   - `architect:` only (v1a) → becomes `project:`.
-    #   - `project:` only (v1b or v2) → left as-is.
-    #   - both present, `project:` empty and `architect:` non-empty → the
-    #     corruption from the old silent-default read path; take `architect:`.
-    #   - both present and non-empty: identical → keep; differing → raise
-    #     rather than silently pick one and lose data.
-    # Idempotent, so a canonical v2 space is a no-op through this method.
-    def self.normalize_schema!(data, metadata_path)
-      version = data["version"]
-      if version.is_a?(Integer) && version > SCHEMA_VERSION
-        raise Error,
-          "space.yaml schema version #{version} is newer than this gem supports " \
-          "(#{SCHEMA_VERSION}); upgrade space-architect: #{metadata_path}"
-      end
-
-      legacy = data.delete("architect")
-      current = data["project"]
-
-      data["project"] =
-        if legacy.nil?
-          current
-        elsif current.nil? || empty_project_block?(current)
-          legacy
-        elsif legacy == current
-          current
-        else
-          raise Error,
-            "#{metadata_path} has both 'architect:' and 'project:' blocks with " \
-            "conflicting content; resolve manually.\narchitect: #{legacy.inspect}\n" \
-            "project: #{current.inspect}"
-        end
-
-      data["version"] = SCHEMA_VERSION
-    end
-    private_class_method :normalize_schema!
-
-    def self.empty_project_block?(block)
-      block.is_a?(Hash) && Array(block["iterations"]).empty? && block["current_iteration"].nil?
-    end
-    private_class_method :empty_project_block?
-
-    def initialize(path, data)
-      @path = Pathname.new(path)
-      @data = data
-    end
-
-    def id
-      data.fetch("id")
-    end
-
-    def title
-      data.fetch("title")
-    end
-
-    def status
-      data.fetch("status", "active")
-    end
-
-    def repos
-      Array(data["repos"]).map do |repo|
-        repo.is_a?(Hash) ? self.class.stringify_keys(repo) : { "name" => repo.to_s }
-      end
-    end
-
-    def provision_scripts
-      Array(data.dig("pack", "provision")).map(&:to_s)
-    end
-
-    def persist_paths
-      Array(data.dig("pack", "persist")).map(&:to_s)
-    end
-
-    # Host env vars to forward into the container at `space run` (bare passthrough).
-    # Declared per-space so payloads needing credentials run without a wall of flags.
-    def run_env
-      Array(data.dig("run", "env")).map(&:to_s)
-    end
-
-    def architect
-      data["project"]
-    end
-
-    def architect=(val)
-      data["project"] = val
-    end
-
-    def metadata_path
-      path.join(METADATA_FILE)
-    end
-
-    def save
-      AtomicWrite.write(metadata_path, YAML.dump(data))
-      self
-    end
-
-    def update_status(status, now: Time.now)
-      normalized = status.to_s.downcase
-      unless VALID_STATUSES.include?(normalized)
-        raise InvalidStatusError, "Invalid status '#{status}'. Expected one of: #{VALID_STATUSES.join(', ')}"
-      end
-
-      data["status"] = normalized
-      data["updated_at"] = now.iso8601
-      save
-    end
-
-    def add_repo(reference, relative_path:, now: Time.now)
-      repo_data = repo_data_for(reference, relative_path:, now:)
-      existing = repos.find do |repo|
-        repo["full_name"] == repo_data["full_name"] ||
-          repo["path"] == repo_data["path"] ||
-          repo["name"] == repo_data["name"]
-      end
-      if existing
-        raise RepoExistsError, "Repo '#{repo_data['full_name']}' already exists in #{id}"
-      end
-
-      data["repos"] = repos + [repo_data]
-      data["updated_at"] = now.iso8601
-      save
-      repo_data
-    end
-
-    private
-
-    def repo_data_for(reference, relative_path:, now:)
-      {
-        "provider" => reference.provider,
-        "organization" => reference.owner,
-        "name" => reference.name,
-        "full_name" => reference.full_name,
-        "clone_url" => reference.clone_url,
-        "path" => relative_path.to_s,
-        "added_at" => now.iso8601
-      }
-    end
-  end
-end

data/lib/space_core/space_store.rb

@@ -1,319 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "async"
-require "async/semaphore"
-require "pathname"
-require "time"
-require "dry/monads"
-require "space_src/scm/git"
-require "space_src/cloner"
-
-module Space::Core
-  class SpaceStore
-    include Dry::Monads[:result, :maybe]
-
-    MAX_CONCURRENT_CLONES = 5
-
-    attr_reader :config, :state, :now
-
-    def initialize(config:, state:, now: -> { Time.now })
-      @config = config
-      @state = state
-      @now = now
-    end
-
-    def spaces_dir
-      config.spaces_dir
-    end
-
-    def create(title, git: true, git_client: GitClient.new)
-      FileUtils.mkdir_p(spaces_dir)
-      timestamp = now.call
-      id = unique_id("#{timestamp.strftime('%Y%m%d')}-#{Slugger.slug(title)}")
-      path = spaces_dir.join(id)
-
-      FileUtils.mkdir_p(path.join("repos"))
-      FileUtils.mkdir_p(path.join("notes"))
-      FileUtils.mkdir_p(path.join("architecture"))
-      FileUtils.mkdir_p(path.join("tmp"))
-      FileUtils.mkdir_p(path.join("build"))
-      File.write(path.join("build", ".keep"), "")
-
-      space = Space.new(path, metadata_for(id:, title:, timestamp:))
-      space.save
-      write_readme(path:, title:, id:, timestamp:)
-      init_git(path:, id:, git_client:) if git
-      state.touch_recent(id)
-      Success(space)
-    rescue Error => e
-      Failure(e)
-    end
-
-    def list
-      return [] unless spaces_dir.directory?
-
-      Paths.layout_children(spaces_dir).select(&:directory?).filter_map do |child|
-        Space.load(child)
-      rescue NotFoundError, Error
-        nil
-      end.sort_by(&:id)
-    end
-
-    def find(identifier = nil, from: Dir.pwd)
-      value = identifier.to_s.strip
-      return current(from:) if value.empty?
-
-      if looks_like_path?(value)
-        begin
-          return Success(Space.load(File.expand_path(value)))
-        rescue Error => e
-          return Failure(e)
-        end
-      end
-
-      matches = matching_spaces(value)
-      return Success(matches.first) if matches.length == 1
-
-      if matches.empty?
-        return Failure(NotFoundError.new("Could not find space matching '#{value}' in #{spaces_dir}"))
-      end
-
-      Failure(AmbiguousSpaceError.new("Space '#{value}' is ambiguous: #{matches.map(&:id).join(', ')}"))
-    rescue Error => e
-      Failure(e)
-    end
-
-    def current(from: Dir.pwd)
-      current_from_pwd(from:).to_result(CurrentSpaceMissingError.new("No current space found from #{from}. Run this inside a space or pass a space id."))
-    rescue Error => e
-      Failure(e)
-    end
-
-    def current_from_pwd(from: Dir.pwd)
-      path = Pathname.new(File.expand_path(from.to_s))
-      path = path.dirname if path.file?
-
-      loop do
-        return Some(Space.load(path)) if path.join(Space::METADATA_FILE).exist?
-        break if path.root?
-
-        path = path.parent
-      end
-
-      None()
-    end
-
-    def path_for(identifier = nil)
-      find(identifier).fmap(&:path)
-    end
-
-    def use(identifier)
-      find(identifier).fmap { |space| state.touch_recent(space.id); space }
-    end
-
-    def add_repo(spec, from: Dir.pwd, scm: ::Space::Src::SCM::Git.new, cloner: nil, mise_client: MiseClient.new)
-      add_repos([spec], from:, scm:, cloner:, mise_client:).fmap(&:first)
-    end
-
-    def add_repos(specs, from: Dir.pwd, scm: ::Space::Src::SCM::Git.new, cloner: nil, mise_client: MiseClient.new, reporter: nil)
-      current(from:).bind { |space| add_repos_to(space, specs, scm:, cloner:, mise_client:, reporter:) }
-    end
-
-    def add_repos_to(space, specs, scm: ::Space::Src::SCM::Git.new, cloner: nil, mise_client: MiseClient.new, reporter: nil)
-      additions = prepare_repo_additions(space, specs)
-      first_error = nil
-
-      Async do |task|
-        semaphore = Async::Semaphore.new(MAX_CONCURRENT_CLONES, parent: task)
-
-        clone_tasks = additions.map do |addition|
-          semaphore.async(finished: false) do
-            clone_addition(addition, scm:, cloner:, mise_client:, reporter:)
-          end
-        end
-
-        # Collect results without raising inside the reactor so the outer task
-        # succeeds and async does not log "Task may have ended" for our errors.
-        clone_tasks.each do |ct|
-          ct.wait
-        rescue StandardError => e
-          first_error ||= e
-        end
-      end.wait
-
-      return Failure(first_error) if first_error
-
-      Success(additions.map do |addition|
-        repo_data = space.add_repo(addition.fetch(:reference), relative_path: addition.fetch(:relative_path), now: now.call)
-        { space: space, repo: repo_data, reference: addition.fetch(:reference), path: addition.fetch(:path) }
-      end)
-    rescue Error => e
-      Failure(e)
-    end
-
-    def repos(from: Dir.pwd)
-      current(from:).fmap(&:repos)
-    end
-
-    private
-
-    def clone_addition(addition, scm:, cloner:, mise_client:, reporter: nil)
-      reporter&.start(addition)
-      fetch_addition(addition, scm:, cloner:)
-      reporter&.trust(addition)
-      mise_client.trust(addition.fetch(:path))
-      reporter&.finish(addition)
-      addition
-    rescue StandardError
-      reporter&.fail(addition)
-      raise
-    end
-
-    # Prefer a fast local src copy; fall back to a network clone only when no
-    # src copy is available.
-    def fetch_addition(addition, scm:, cloner:)
-      reference = addition.fetch(:reference)
-      destination = addition.fetch(:path)
-      source = addition.fetch(:src_source)
-
-      if source&.directory?
-        actual_cloner = cloner || ::Space::Src::Cloner.new(base_dir: config.src_dir)
-        result = actual_cloner.call(name: reference.full_name, into: destination.dirname.to_s)
-        raise GitError, "clone failed (copy): #{result.failure}" if result.failure?
-      else
-        result = scm.clone(reference.clone_url, destination.to_s)
-        raise GitError, "clone failed: #{result.failure[:stderr]}" if result.failure?
-      end
-    end
-
-    def prepare_repo_additions(space, specs)
-      src_dir = config.src_dir
-      additions = specs.map do |spec|
-        reference = RepoResolver.new(config).resolve(spec)
-        relative_path = Pathname.new("repos").join(reference.directory_name)
-        destination = space.path.join(relative_path)
-
-        ensure_repo_can_be_added!(space, reference, relative_path, destination)
-
-        {
-          reference: reference,
-          relative_path: relative_path,
-          path: destination,
-          src_source: src_dir && reference.src_path(src_dir)
-        }
-      end
-
-      duplicate_paths = additions
-        .map { |addition| addition.fetch(:path).to_s }
-        .tally
-        .select { |_path, count| count > 1 }
-        .keys
-      unless duplicate_paths.empty?
-        raise RepoExistsError, "Multiple repos resolve to the same destination: #{duplicate_paths.join(', ')}"
-      end
-
-      additions
-    end
-
-    def ensure_repo_can_be_added!(space, reference, relative_path, destination)
-      raise RepoExistsError, "Repo destination already exists: #{destination}" if destination.exist?
-
-      existing = space.repos.find do |repo|
-        repo["full_name"] == reference.full_name ||
-          repo["path"] == relative_path.to_s ||
-          repo["name"] == reference.name
-      end
-      return unless existing
-
-      raise RepoExistsError, "Repo '#{reference.full_name}' already exists in #{space.id}"
-    end
-
-    def metadata_for(id:, title:, timestamp:)
-      iso_timestamp = timestamp.iso8601
-      {
-        "version" => 2,
-        "id" => id,
-        "title" => title,
-        "status" => "active",
-        "created_at" => iso_timestamp,
-        "updated_at" => iso_timestamp,
-        "repos" => [],
-        "notes" => [],
-        "tickets" => [],
-        "tags" => []
-      }
-    end
-
-    def write_readme(path:, title:, id:, timestamp:)
-      AtomicWrite.write(path.join("README.md"), <<~README)
-        # #{title}
-
-        Space: `#{id}`
-        Created: #{timestamp.iso8601}
-
-        ## Organization
-
-        - `space.yaml` tracks the space identity, status, and associated metadata.
-        - `repos/` contains cloned Git repositories for this work.
-        - `notes/` is for task notes, scratch docs, and thinking-in-progress.
-        - `architecture/` holds the architect project memory (ARCHITECT.md and the per-iteration files).
-        - `tmp/` is the workspace-local scratch directory. Use it instead of `/tmp` or
-          `/var/tmp`; when using `mktemp`, use `tmp/` as the base directory.
-        - `build/` holds the architect loop's per-lane worktrees and scratch
-          (gitignored except `.keep`).
-        - The space is a Git repository so notes and architecture are versioned.
-          `repos/`, `tmp/`, and `build/` are gitignored, keeping the cloned repos and scratch
-          out of the space's history (each clone keeps its own Git repo).
-      README
-    end
-
-    # Make the space itself a Git repo so its notes/architecture are versioned.
-    # `repos/` and `tmp/` are ignored: the clones keep their own `.git`, and a
-    # space-level `git add` must never pull them in as embedded-repo gitlinks.
-    def init_git(path:, id:, git_client:)
-      write_gitignore(path)
-      git_client.init(path)
-      git_client.commit_all(path, "Initialize space #{id}")
-    end
-
-    def write_gitignore(path)
-      AtomicWrite.write(path.join(".gitignore"), <<~GITIGNORE)
-        repos/
-        tmp/
-        build/
-        !build/.keep
-      GITIGNORE
-    end
-
-    def unique_id(base_id)
-      candidate = base_id
-      counter = 2
-
-      while spaces_dir.join(candidate).exist?
-        candidate = "#{base_id}-#{counter}"
-        counter += 1
-      end
-
-      candidate
-    end
-
-    def looks_like_path?(value)
-      value.include?(File::SEPARATOR) || value.start_with?("~") || value.start_with?(".")
-    end
-
-    def matching_spaces(value)
-      all = list
-      exact = all.select { |space| space.id == value }
-      return exact unless exact.empty?
-
-      suffix = all.select { |space| space.id.end_with?("-#{value}") }
-      return suffix unless suffix.empty?
-
-      prefix = all.select { |space| space.id.start_with?(value) }
-      return prefix unless prefix.empty?
-
-      all.select { |space| space.id.include?(value) }
-    end
-  end
-end

data/lib/space_core/state.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "pathname"
-
-module Space::Core
-  class State
-    DEFAULT_DATA = {
-      "version" => 1,
-      "current_space" => nil,
-      "recent" => []
-    }.freeze
-
-    attr_reader :path, :data, :env
-
-    def self.default_path(env: ENV)
-      XDG.state_home(env: env).join("space-architect", "state.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
-    end
-
-    def load
-      @data = if path.exist?
-                parsed = YAML.safe_load(path.read, aliases: false) || {}
-                unless parsed.is_a?(Hash)
-                  raise Error, "State file must contain a YAML mapping: #{path}"
-                end
-
-                default_data.merge(stringify_keys(parsed))
-              else
-                default_data
-              end
-      self
-    end
-
-    def ensure_exists!
-      save unless path.exist?
-      self
-    end
-
-    def save
-      AtomicWrite.write(path, YAML.dump(data))
-      self
-    end
-
-    def current_space
-      data["current_space"]
-    end
-
-    def current_space=(space_id)
-      data["current_space"] = space_id
-    end
-
-    def recent
-      Array(data["recent"])
-    end
-
-    def touch_current(space_id)
-      self.current_space = space_id
-      touch_recent(space_id)
-    end
-
-    def touch_recent(space_id)
-      data["recent"] = ([space_id] + recent).compact.uniq.first(20)
-      save
-    end
-
-    private
-
-    def default_data
-      DEFAULT_DATA.merge("recent" => [])
-    end
-
-    def stringify_keys(hash)
-      hash.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
-    end
-  end
-end

data/lib/space_core/templates/oci/dockerfile.erb

@@ -1,73 +0,0 @@
-# Generated by `space pack` for space: <%= space_id %>
-# Build (run from the space root):
-#   docker build -f <output_dir>/Dockerfile -t <%= space_id %>:latest .
-#
-# Run (auth injected at runtime — never baked into layers):
-#   container run --rm -it \
-#     -e ANTHROPIC_API_KEY=<key> \
-<% persist_paths.each do |guest_path| -%>
-#     -v .state<%= guest_path %>:<%= guest_path %> \
-<% end -%>
-#     <%= space_id %>:latest
-<% if persist_paths.any? -%>
-# (Persist: host paths are relative to space root; create them before first run.)
-<% end -%>
-#
-# Available env vars at runtime:
-#   ANTHROPIC_API_KEY          — API key
-#   CLAUDE_CODE_OAUTH_TOKEN    — alternative to API key
-#   ANTHROPIC_BASE_URL         — optional proxy endpoint
-
-FROM ruby:4.0.5
-
-RUN apt-get update -qq \
- && apt-get install -y --no-install-recommends \
-      git \
-      curl \
-      ca-certificates \
- && rm -rf /var/lib/apt/lists/*
-
-# Claude Code CLI (https://claude.ai/install.sh)
-RUN curl -fsSL https://claude.ai/install.sh | bash
-
-# Write entrypoint: sets git safe.directory, execs requested command or a login shell
-RUN echo '<%= entrypoint_b64 %>' | base64 -d > /entrypoint.sh \
- && chmod +x /entrypoint.sh
-
-# Prepend gem-exec and payload bin dirs so login shells (bash --login) resolve architect/space/claude
-RUN printf 'export PATH="/usr/local/bundle/bin:/root/.local/bin:$PATH"\n' \
- > /etc/profile.d/space-architect.sh
-<% if provision_scripts.any? -%>
-
-# Space-declared build-time provisioning (pack.provision)
-# Each script is COPY'd individually — a space-content edit elsewhere does not bust its cache layer.
-<% provision_scripts.each do |script| -%>
-COPY <%= script %> /space/<%= script %>
-RUN /space/<%= script %>
-<% end -%>
-<% end -%>
-
-# Install space-architect gem
-<% if local_space_architect? -%>
-COPY repos/space-architect /space/repos/space-architect
-RUN cd /space/repos/space-architect \
- && rake build \
- && gem install --no-document pkg/*.gem
-<% else -%>
-RUN gem install --no-document space-architect
-<% end -%>
-
-# Copy the space tree into the image (filtered by Dockerfile.dockerignore alongside this Dockerfile)
-COPY . /space
-<% if persist_paths.any? -%>
-
-# Seed snapshot: capture baked content of persisted dirs so a first-run (empty) mount is seeded from it
-<% persist_paths.each do |guest_path| -%>
-RUN mkdir -p "/opt/space-seed<%= guest_path %>" && cp -a "<%= guest_path %>/." "/opt/space-seed<%= guest_path %>/" 2>/dev/null || true
-<% end -%>
-<% end -%>
-
-WORKDIR /space
-
-ENTRYPOINT ["/entrypoint.sh"]
-CMD ["bash", "--login"]

data/lib/space_core/templates/oci/dockerignore.erb

@@ -1,17 +0,0 @@
-# Build scratch: worktrees, harness output, builder artefacts
-build/
-
-# Temp workspace
-tmp/
-notes/tmp/
-
-# Secrets — NEVER bake credentials in image layers
-.env
-**/.env
-*.key
-*.pem
-*.p12
-*.pfx
-id_rsa
-id_ecdsa
-id_ed25519

data/lib/space_core/templates/oci/entrypoint.sh.erb

@@ -1,16 +0,0 @@
-#!/bin/bash
-set -e
-git config --global --add safe.directory '*'
-git config --global --get user.name >/dev/null 2>&1 || git config --global user.name 'space-architect'
-git config --global --get user.email >/dev/null 2>&1 || git config --global user.email 'architect@localhost'
-<% persist_paths.each do |guest_path| -%>
-if [ -d "/opt/space-seed<%= guest_path %>" ] && [ -z "$(ls -A "<%= guest_path %>" 2>/dev/null)" ]; then
-  mkdir -p "<%= guest_path %>"
-  cp -a "/opt/space-seed<%= guest_path %>/." "<%= guest_path %>/" 2>/dev/null || true
-fi
-<% end -%>
-if [ "$#" -eq 0 ]; then
-  exec bash --login
-else
-  exec "$@"
-fi