rubik 0.1.0

data/lib/rubik/storage/layout.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../uris"
+
+module Rubik
+  module Storage
+    # Dosya düzeni SSOT: storage kökü, proje slug'ı, absorbe edilen oturum /
+    # subagent transcript yolları — yazıcı (Store, Service, supervisor) ve
+    # okuyucu (read_file rubik:// rotaları, Session::Manager) aynı kararı
+    # buradan alır; TranscriptFormatter'daki "tek karar noktası" ilkesinin
+    # storage tarafındaki karşılığı.
+    module Layout
+      module_function
+
+      DEFAULT_ROOT = "~/.rubik/rubikstorage"
+
+      # Noktalı anahtar okuması her iki config şeklinde aynı çalışsın:
+      # Rubik::Config#fetch noktalı yolları böler, düz Hash#fetch BÜTÜN
+      # dizgiyi tek anahtar sayar — Hash için dig, diğerleri için fetch.
+      def config_get(config, key, default = nil)
+        return default if config.nil?
+
+        val = if config.is_a?(Hash)
+                config.dig(*key.to_s.split("."))
+              elsif config.respond_to?(:fetch)
+                config.fetch(key, nil)
+              end
+        val.nil? ? default : val
+      end
+
+      # storage.root yapılandırması (~ dahil) — EXPAND_PATH Home'u kendisi
+      # çözer; boş/nil değer DEFAULT_ROOT'a düşer.
+      def storage_root(config = nil)
+        raw = config_get(config, "storage.root", DEFAULT_ROOT).to_s.strip
+        File.expand_path(raw.empty? ? DEFAULT_ROOT : raw)
+      end
+
+      # storage.project override'u varsa o, yoksa worktree kök dizininin
+      # adı slug'laştırılır (nil/boş root_dir Dir.pwd'e düşer — bazı test
+      # kabukları root_dir'siz kurulur).
+      def project_slug(root_dir = Dir.pwd, config = nil)
+        source = config_get(config, "storage.project", nil).to_s.strip
+        clean_root = root_dir.to_s.strip.empty? ? Dir.pwd : root_dir
+        source = File.basename(File.expand_path(clean_root)) if source.empty?
+        slugify(source)
+      end
+
+      # [a-z0-9._-] dışını tireye çevirir; boş kalırsa "default".
+      def slugify(name)
+        slug = name.to_s.downcase.gsub(/[^a-z0-9._-]+/, "-").gsub(/\A[-.]+|[-.]+\z/, "")
+        slug.empty? ? "default" : slug
+      end
+
+      def project_dir(root, slug)
+        File.join(root, slug)
+      end
+
+      def store_dir(project_directory)
+        File.join(project_directory, "store")
+      end
+
+      def index_path(root)
+        File.join(root, "index.json")
+      end
+
+      def entities_path(project_directory, type)
+        File.join(store_dir(project_directory), "#{type}.jsonl")
+      end
+
+      def meta_path(project_directory)
+        File.join(store_dir(project_directory), "meta.json")
+      end
+
+      # Absorb (storage.absorb_artifacts): yeni oturum dosyaları ve subagent
+      # transcriptları worktree'deki .rubik/ yerine proje storage köküne
+      # yazılır; okuyucular önce absorbe yolu, sonra eski yolu tarar.
+      # Dikkat (DI doktrini): config yoksa veya anahtar eksikse LEGACY kalır
+      # — defaults.yaml'daki true değeri üretimde absorb'u açar; bare
+      # construction'lar (testler) davranış değişikliği görmez.
+      def absorb_artifacts?(config = nil)
+        return false if config.nil?
+
+        config_get(config, "storage.absorb_artifacts", false)
+      end
+
+      # Recorder'ın kullanacağı oturum dizini: absorb açıksa proje storage
+      # kökü, değilse worktree'deki klasik .rubik/sessions.
+      def sessions_dir_for(root_dir, config = nil)
+        clean_root = root_dir.to_s.strip.empty? ? Dir.pwd : root_dir
+        return File.join(File.expand_path(clean_root), ".rubik", "sessions") unless absorb_artifacts?(config)
+
+        absorbed_sessions_dir(storage_root(config), project_slug(clean_root, config))
+      end
+
+      def absorbed_sessions_dir(root, slug)
+        File.join(project_dir(root, slug), "sessions")
+      end
+
+      def absorbed_transcript_path(root, slug, id)
+        File.join(project_dir(root, slug), "subagents", id, "transcript.jsonl")
+      end
+
+      # Fiziksel storage yolu -> kanonik rubik:// okuma rotaları. Sandbox
+      # kapısı diagnostic'ına beslenir: engellenen yol merkezi storage
+      # altındaysa aynı içerik, sandbox'ı genişletmeden izinli rotadan
+      # okunabilir (js-tangram olay raporu 2026-10-04, olay #1). Yol storage
+      # kökünün altında değilse, hedef proje gerçekten depo verisi içermiyorsa
+      # veya yol normalize edilemezse boş dizi — ipucu üretimi en iyi çabadır,
+      # asla raise etmez. config=nil DEFAULT_ROOT varsayar; config'li
+      # kurulumlarda kök farklıysa dürüstçe ipucu yok.
+      def storage_route_hints(path, config = nil)
+        root = storage_root(config)
+        expanded = File.expand_path(path.to_s)
+        return [] unless expanded.start_with?("#{root}/", "#{root}\\")
+
+        rel = expanded.delete_prefix(root).tr("\\", "/").sub(%r{\A/}, "")
+        return [Rubik::Uris.storage_index] if rel == "index.json" && File.exist?(index_path(root))
+
+        project, *rest = rel.split("/")
+        return [] if project.to_s.strip.empty?
+
+        project = slugify(project)
+        # Yanlış-pozitif gönderme (olay takibi M2): custom storage.root
+        # kurulumlarında DEFAULT kök altındaki bayat yollar "depo içi"
+        # sanılıp var olmayan rotalara yönlendirilmesin — ipucu yalnız
+        # gerçekten depo verisi olan projelere verilir.
+        return [] unless File.exist?(project_dir(root, project))
+
+        if rest.size == 2 && rest[0] == "store" && rest[1].end_with?(".jsonl")
+          [Rubik::Uris.storage_listing(project: project, type: rest[1].delete_suffix(".jsonl"))]
+        elsif rest.size == 3 && rest[0] == "subagents" && rest[2] == "transcript.jsonl"
+          [Rubik::Uris.subagent_transcript(rest[1]),
+           Rubik::Uris.storage_listing(project: project, type: "transcript")]
+        else
+          # store/meta.json dahil bilinmeyen her şekil: proje özeti en yakın
+          # dürüst adres — oradan tüm rotalar liste çıktısında görünür.
+          [Rubik::Uris.storage_project(project: project)]
+        end
+      rescue ArgumentError, TypeError
+        [] # bozuk ~kullanıcı ya da tipli girdi: ipucu yok, kapı mesajı aynen
+      end
+    end
+  end
+end

data/lib/rubik/storage/render.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../uris"
+
+module Rubik
+  module Storage
+    # Okuma düzlemi biçimlendiricisi: rubik://storage URI'leri read_file
+    # üzerinden okunduğunda insan/ajan-okur markdown, ".json" ekinde ham
+    # JSON üretilir. Yazı katmanı (Store) hash döndürür; biçim burada kalır.
+    module Render
+      module_function
+
+      def entity(record, project:)
+        <<~MD
+          # #{record['id']}
+
+          **Type:** #{record['type']} · **Row:** #{record['row']} · **Status:** #{record['status']} · **Version:** #{record['version']}
+          **Title:** #{record['title']}
+          **Created:** #{record['created_at']} · **Updated:** #{record['updated_at']}
+          **Hash:** #{record['hash']}
+          **Tags:** #{Array(record['tags']).join(', ')}
+          #{links_line(record)}
+          **URI:** #{Rubik::Uris.storage_entity(project: project, type: record['type'], id: record['id'])}
+
+          ---
+
+          #{record['body'].to_s.empty? ? '(no body)' : record['body']}
+        MD
+      end
+
+      def listing(project:, type:, summaries:, uri_hint: nil, refs: {})
+        header = "# #{project}/#{type}\n\n"
+        header << "_Read list entries via #{uri_hint}_\n\n" if uri_hint
+        header << "| row | id | status | updated | title |\n|---|---|---|---|---|\n"
+        pointed = refs.select { |_alias, id| id.start_with?("#{type}.") }
+        header << "Refs: #{pointed.map { |a, id| "#{a} → #{id}" }.join('; ')}\n\n" unless pointed.empty?
+        return header << "_(empty — no #{type} entities yet)_\n" if summaries.empty?
+
+        summaries.each do |s|
+          title = s[:title].to_s.gsub("|", "\\|").slice(0, 80)
+          header << "| #{s[:row]} | `#{s[:id]}` | #{s[:status]} | #{s[:updated_at]} | #{title} |\n"
+        end
+        header
+      end
+
+      # Kompakt terminal kartı (!storage komutu): meta gürültüsü (Hash,
+      # Version) yok — kimlik satırı + URI + gövde. Varlık birden çok
+      # ref'e bağlıysa ilk alias görünür (tamamı !storage refs'te); alias
+      # yoksa başlıkta ref belirtilmez.
+      def card(record, project:, refs: {})
+        alias_name = refs.key(record["id"])
+        head = "📝 #{record['title']} — #{record['type']}.#{record['row']} · #{record['status']} · updated #{record['updated_at']}"
+        head << " · ref: #{alias_name}" if alias_name
+        body = record["body"].to_s.empty? ? "(no body)" : record["body"].to_s.chomp
+        <<~CARD
+          #{head}
+          URI: #{Rubik::Uris.storage_entity(project: project, type: record['type'], id: record['id'])}
+
+          #{body}
+        CARD
+      end
+
+      def project(project_name, summary)
+        counts = summary["entity_counts"].to_h.map { |t, n| "#{t}: #{n}" }.join(", ")
+        refs = summary["refs"].to_h.map { |k, v| "#{k} → #{v}" }.join("; ")
+        <<~MD
+          # Storage project: #{project_name}
+
+          **Path:** #{summary['path']}
+          **Entities:** #{counts.empty? ? '(none)' : counts}
+          **Created:** #{summary['created_at']} · **Updated:** #{summary['updated_at']}
+          **Refs:** #{refs.empty? ? '(none)' : refs}
+        MD
+      end
+
+      def index(snapshot)
+        out = +"# Rubik storage central index\n\n"
+        out << "**Root updated:** #{snapshot['updated_at'] || '(never written)'}\n\n"
+        projects = snapshot["projects"].to_h
+        return out << "_(no projects registered yet)_\n" if projects.empty?
+
+        out << "| project | entities | updated |\n|---|---|---|\n"
+        projects.sort.each do |name, entry|
+          total = entry["entity_counts"].to_h.values.sum
+          out << "| #{name} | #{total} (#{entry['entity_counts'].to_h.map { |t, n| "#{t}=#{n}" }.join(' ')}) | #{entry['updated_at']} |\n"
+        end
+        out
+      end
+
+      def links_line(record)
+        links = record["links"].to_h
+        links.empty? ? "**Links:** (none)" : "**Links:** #{links.map { |k, v| "#{k}=#{v}" }.join(', ')}"
+      end
+    end
+  end
+end

data/lib/rubik/storage/service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../coeffects"
+require_relative "layout"
+require_relative "store"
+require_relative "../runtime/service_registration"
+
+module Rubik
+  module Storage
+    # Kompozisyon kökü kancası (repl/lifecycle.rb Phase 4): storage
+    # açıksa Store inşa edilir ve STORAGE_STORE coeffect'i olarak
+    # bağlama sağlanır — Runtime::IndexService kayıt sırtını (ServiceRegistration)
+    # izler. Kapalıysa nil döner; hiçbir şey provide edilmez, araç katmanı
+    # dürüst "storage disabled" hatası verir.
+    module Service
+      module_function
+
+      def enabled?(config = nil)
+        return true if config.nil?
+
+        Layout.config_get(config, "storage.enabled", true)
+      end
+
+      def build(config: nil, root_dir: Dir.pwd)
+        return nil unless enabled?(config)
+
+        Store.new(root: Layout.storage_root(config), project: Layout.project_slug(root_dir, config))
+      end
+
+      def register(context_or_manager, store)
+        return nil unless store
+
+        Runtime::ServiceRegistration.call(context_or_manager) do |ctx|
+          next store unless ctx
+
+          ctx.provide(Rubik::Coeffects::STORAGE_STORE, store)
+          store
+        end
+      end
+    end
+  end
+end