rubik 0.1.0

data/lib/rubik/security/redactor.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Security
+    module Redactor
+      MASK_STRING = "***MASKED***"
+
+      PATTERNS = [
+        /sk-ant-[a-zA-Z0-9_-]{20,}/,
+        /sk-[a-zA-Z0-9_-]{20,}/,
+        /AKIA[0-9A-Z]{16}/,
+        /ghp_[a-zA-Z0-9]{36}/,
+        /github_pat_[a-zA-Z0-9_]{22,}/,
+        /AIzaSy[a-zA-Z0-9_-]{33}/,
+        /\bbearer\s+[a-zA-Z0-9_\-.]{20,}/i,
+        /-----BEGIN [A-Z0-9_\s-]+PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9_\s-]+PRIVATE KEY-----/,
+        %r{(https?://[^:]+:)([^@]+)@}
+      ].freeze
+
+      ASSIGNMENT_KEY_REGEX = /\b(password|passwd|api_key|secret)(\s*[:=]\s*)(['"][^'"]*['"]|[^\s,;'"]+)/i
+      ASSIGNMENT_TOKEN_REGEX = /\b(token)(\s*[:=]\s*)(['"][^'"]*['"]|[^\s,;'"]+)/i
+
+      # Anahtar-maskeleme desenleri (Session::Recorder#mask_payload ile aynı
+      # aile): sır görünümlü anahtarların değerleri desen eşleşmese bile
+      # maskelenir; sayaç anahtarları (tokens, max_tokens) istisnadır.
+      SECRET_KEY_REGEX = /(api_key|auth|password|secret|_token\b|^token\b)/i
+      TOKEN_COUNT_REGEX = /(tokens|token_count|max_tokens)/i
+
+      def self.redact(text)
+        return text unless text.is_a?(String)
+        return text if text.empty?
+
+        # scrub: redact ham geçmişe (tool çıktısı, prompt) dokunur — geçersiz
+        # UTF-8 gsub!'ı ArgumentError ile düşürür; total olmak maskenin
+        # kendisi bir arıza kaynağı olmasın demektir.
+        result = text.dup.scrub
+        PATTERNS.each do |pattern|
+          if pattern == %r{(https?://[^:]+:)([^@]+)@}
+            result.gsub!(pattern, "\\1#{MASK_STRING}@")
+          else
+            result.gsub!(pattern, MASK_STRING)
+          end
+        end
+
+        result.gsub!(ASSIGNMENT_KEY_REGEX) do
+          "#{Regexp.last_match(1)}#{Regexp.last_match(2)}#{MASK_STRING}"
+        end
+
+        result.gsub!(ASSIGNMENT_TOKEN_REGEX) do |match|
+          prefix = Regexp.last_match(1)
+          sep = Regexp.last_match(2)
+          val = Regexp.last_match(3)
+          if val =~ /\A['"]?\d+['"]?\z/
+            match
+          else
+            "#{prefix}#{sep}#{MASK_STRING}"
+          end
+        end
+
+        result
+      end
+
+      # Bir payload ağacında (Hash/Array/String) her metne redact uygular ve
+      # sır görünümlü anahtarların değerlerini komple maskeler — kalıcı
+      # serileştirmeden önce satır başına çağrılır (transcript sağlığı
+      # paketi 2026-10-10; Session::Recorder#mask_payload ile eş davranış).
+      # Girdiyi asla mutemez: her düzey yeni yapı döner. Sözleşme: satırlar
+      # düz haritalardır (derinlik provider JSON parse'ında max_nesting ile
+      # sınırlı) — döngü koruması JSON üretim katının (clean_utf8_deep)
+      # işidir; buraya döngülü yapı verilirse StackError çağıranındır.
+      def self.mask_value(payload)
+        case payload
+        when Hash
+          payload.each_with_object({}) do |(k, v), h|
+            key_str = k.to_s
+            is_secret_key = key_str.match?(SECRET_KEY_REGEX) && !key_str.match?(TOKEN_COUNT_REGEX)
+            h[k] = is_secret_key ? MASK_STRING : mask_value(v)
+          end
+        when Array
+          payload.map { |v| mask_value(v) }
+        when String
+          redact(payload)
+        else
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/rubik/security.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "security/errors"
+require_relative "security/redactor"
+require_relative "security/guard"
+require_relative "security/classifier"
+
+module Rubik
+  module Security
+  end
+end

data/lib/rubik/session/manager.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require_relative "replayer"
+require_relative "../llm/message_sanitizer"
+require_relative "../prompt/context_compactor"
+
+module Rubik
+  module Session
+    class Manager
+      PROMPT_EVENT_TYPES = ["prompt", "input", "user_turn", "repl_command"].freeze
+
+      def self.project_sessions_dir(root_dir = Dir.pwd)
+        File.join(File.expand_path(root_dir), ".rubik", "sessions")
+      end
+
+      # Absorb (storage.absorb_artifacts): storage köküne absorbe edilmiş
+      # oturum dizini. Recorder oraya yazdığında eski .rubik/sessions yanında
+      # görünür kalır; dizin yoksa Dir.directory? zaten atlar. Config threading
+      # (review bulgusu 2): recorder storage.root/project OVERRIDE'una saygı
+      # duyarak yazar — okuma tarafı da aynı config'i almalı; bare çağrılar
+      # (config nil) varsayılan kökte kalır.
+      def self.absorbed_sessions_dir(root_dir = Dir.pwd, config = nil)
+        Rubik::Storage::Layout.absorbed_sessions_dir(Rubik::Storage::Layout.storage_root(config),
+                                                     Rubik::Storage::Layout.project_slug(root_dir, config))
+      end
+
+      def self.global_sessions_dir(home_dir = ENV.fetch("HOME", nil))
+        File.join(File.expand_path(home_dir || "."), ".rubik", "sessions")
+      end
+
+      def self.list_sessions(root_dir = Dir.pwd, home_dir = ENV.fetch("HOME", nil), config: nil)
+        dirs = [absorbed_sessions_dir(root_dir, config), project_sessions_dir(root_dir), global_sessions_dir(home_dir)]
+        sessions = []
+
+        dirs.each_with_index do |dir, idx|
+          scope = idx < 2 ? :project : :global
+          next unless File.directory?(dir)
+
+          Dir.glob(File.join(dir, "*.jsonl")).each do |file|
+            meta = parse_session_file(file, scope)
+            sessions << meta if meta
+          end
+        end
+
+        # Sort by mtime descending (most recent first)
+        sessions.sort_by { |s| s[:mtime] }.reverse
+      end
+
+      def self.find_latest_session(root_dir = Dir.pwd, home_dir = ENV.fetch("HOME", nil), exclude_file: nil, config: nil)
+        # Absorbed (project-scope) first, then legacy project, then global.
+        [absorbed_sessions_dir(root_dir, config), project_sessions_dir(root_dir), global_sessions_dir(home_dir)].each do |dir|
+          latest = latest_jsonl_in(dir, exclude_file)
+          return latest if latest
+        end
+        nil
+      end
+
+      def self.latest_jsonl_in(dir, exclude_file)
+        return nil unless File.directory?(dir)
+
+        files = Dir.glob(File.join(dir, "*.jsonl"))
+        files.reject! { |f| File.expand_path(f) == File.expand_path(exclude_file) } if exclude_file
+        files.sort_by! { |f| File.mtime(f) }
+        files.last
+      end
+
+      def self.find_session(identifier, root_dir = Dir.pwd, home_dir = ENV.fetch("HOME", nil), config: nil)
+        return identifier if File.exist?(identifier.to_s)
+
+        id_str = identifier.to_s.strip
+        all = list_sessions(root_dir, home_dir, config: config)
+
+        # Match exact filename, basename without ext, or prefix
+        matched = all.find do |s|
+          s[:name] == id_str ||
+            s[:name].sub(/\.jsonl$/, "") == id_str ||
+            s[:id].start_with?(id_str) ||
+            File.basename(s[:path]).include?(id_str)
+        end
+
+        matched ? matched[:path] : nil
+      end
+
+      # Delete recorded session files older than `days`, protecting the
+      # currently active session file (exclude_file). Project sessions are
+      # pruned by default; pass include_global: true to fold in the
+      # ~/.rubik/sessions scope. Dry-run by default (apply: false) so
+      # callers can preview the blast radius; pass apply: true to actually
+      # unlink. Returns a report hash so callers — and tests — can assert
+      # on the outcome without touching the disk.
+      def self.prune_sessions(days:, root_dir: Dir.pwd, home_dir: ENV.fetch("HOME", nil),
+                              exclude_file: nil, apply: false, include_global: false, config: nil)
+        days = days.to_f
+        days = 7.0 unless days.positive?
+        cutoff = Time.now - (days * 86_400)
+        protected = exclude_file && File.expand_path(exclude_file.to_s)
+
+        candidates = []
+        protected_skipped = 0
+        list_sessions(root_dir, home_dir, config: config).each do |s|
+          next if s[:scope] == :global && !include_global
+
+          if protected && same_path?(File.expand_path(s[:path]), protected)
+            protected_skipped += 1
+            next
+          end
+          candidates << s if s[:mtime] < cutoff
+        end
+
+        bytes = candidates.sum { |s| session_file_size(s[:path]) }
+
+        deleted = []
+        if apply
+          candidates.each do |s|
+            File.delete(s[:path])
+            deleted << s[:path]
+          rescue StandardError
+            # a file raced away between listing and unlink — ignore
+          end
+        end
+
+        {
+          cutoff: cutoff,
+          older_than_days: days,
+          candidates: candidates.size,
+          deleted: deleted.size,
+          bytes: bytes,
+          applied: apply,
+          protected_skipped: protected_skipped,
+          sample: candidates.first(5).map { |s| s[:id] }
+        }
+      end
+
+      def self.session_file_size(path)
+        File.size(path)
+      rescue SystemCallError
+        0
+      end
+
+      # Case-insensitive on Windows (its filesystem folds case), exact
+      # elsewhere — so the protected active-session comparison can never
+      # fail to match on casing and let prune delete the live file.
+      def self.same_path?(left, right)
+        return false if left.nil? || right.nil?
+
+        Rubik::Platform.windows? ? left.casecmp?(right) : left == right
+      end
+
+      def self.restore_session(shell, session_file)
+        return { ok: false, error: "Session file not found: #{session_file}" } unless File.exist?(session_file)
+
+        events = []
+        turns = []
+        last_prompt = nil
+
+        File.foreach(session_file) do |line|
+          next if line.strip.empty?
+
+          begin
+            event = JSON.parse(line)
+          rescue JSON::ParserError
+            next
+          end
+
+          events << event
+          type = event["type"].to_s
+          payload = event["payload"]
+
+          case type
+          when "user_turn"
+            content = payload.is_a?(Hash) ? (payload["content"] || payload.to_s) : payload.to_s
+            content = content.sub(/\A!goal\s+/i, "Goal: ")
+            turns << { role: "user", content: content }
+            last_prompt = content
+          when "assistant_response"
+            content = payload.is_a?(Hash) ? (payload["content"] || payload.to_s) : payload.to_s
+            turns << { role: "assistant", content: content }
+          when "repl_command"
+            if payload.is_a?(Hash)
+              cmd = payload["command"]
+              out = payload["output"]
+              if cmd && !cmd.to_s.strip.empty?
+                # Bang syntax stays out of the restored LLM context (Plan 53 D-8);
+                # the session file itself keeps the literal raw command.
+                clean = cmd.to_s.delete_prefix("!")
+                turns << { role: "user", content: clean }
+                last_prompt = clean
+                turns << { role: "assistant", content: out.to_s } if out && !out.to_s.strip.empty?
+              end
+            end
+          when "input", "prompt"
+            content = if payload.is_a?(Hash)
+                        payload["raw"] || payload["content"] || payload["input"] || payload.to_s
+                      else
+                        payload.to_s
+                      end
+            turns << { role: "user", content: content }
+            last_prompt = content
+          when "output", "assistant"
+            content = if payload.is_a?(Hash)
+                        payload["content"] || payload["output"] || payload.to_s
+                      else
+                        payload.to_s
+                      end
+            turns << { role: "assistant", content: content }
+          end
+        end
+
+        if shell.respond_to?(:conversation_history) && shell.conversation_history
+          shell.conversation_history.clear
+          # Plan 61 D-6/D-12: merge consecutive same-role turns left by
+          # failed/legacy sessions, then fit the window to the model's
+          # token budget under the shared conversation-window policy.
+          turns = Rubik::LLM::MessageSanitizer.normalize(turns)
+          ceiling = begin
+            spec = shell.config.model_spec(:default)
+            shell.llm_registry.effective_input_limit_for(spec["provider"], spec["name"])
+          rescue StandardError => e
+            Rubik::Log.warn(:session, "input ceiling lookup failed during restore (#{e.class}: #{e.message}); using nil budget")
+            nil
+          end
+          window = Rubik::Prompt::ContextCompactor.trim_history_to_budget(
+            turns, ceiling: ceiling,
+                   max_entries: Rubik::Prompt::ContextCompactor::DEFAULT_MAX_CONVERSATION_ENTRIES
+          )
+          window.each { |t| shell.conversation_history << t }
+        end
+
+        shell.recorder.switch_session_file(session_file) if shell.respond_to?(:recorder) && shell.recorder
+
+        {
+          ok: true,
+          path: session_file,
+          turns_hydrated: turns.size,
+          event_count: events.size,
+          last_prompt: last_prompt || "No prompt",
+          replayed_count: turns.size
+        }
+      rescue StandardError => e
+        { ok: false, error: "Failed to restore session: #{e.message}" }
+      end
+
+      def self.parse_session_file(file, scope)
+        return nil unless File.exist?(file)
+        return nil if File.empty?(file)
+
+        event_count = 0
+        first_line = nil
+
+        File.open(file, "rb") do |f|
+          first_line = f.gets
+          return nil unless first_line
+
+          last_char = first_line[-1]
+          event_count = first_line.count("\n")
+          buf = +""
+          while f.read(65_536, buf)
+            event_count += buf.count("\n")
+            last_char = buf[-1]
+          end
+          # Count a final line left unterminated by a truncated write.
+          event_count += 1 if last_char && last_char != "\n"
+        end
+
+        first_event = begin
+          JSON.parse(first_line)
+        rescue JSON::ParserError
+          {}
+        end
+
+        last_prompt = nil
+        chunk_size = 4096
+
+        File.open(file, "rb") do |f|
+          size = f.size
+          pos = size
+          buffer = +""
+
+          while pos.positive? && last_prompt.nil?
+            read_len = [pos, chunk_size].min
+            pos -= read_len
+            f.seek(pos)
+            chunk = f.read(read_len)
+            buffer.prepend(chunk)
+
+            lines = buffer.split("\n")
+            buffer = pos.positive? ? (lines.shift || +"") : +""
+
+            lines.reverse_each do |line|
+              next if line.strip.empty?
+
+              ev = begin
+                JSON.parse(line)
+              rescue JSON::ParserError
+                next
+              end
+
+              type = ev["type"].to_s
+              next unless PROMPT_EVENT_TYPES.include?(type)
+
+              payload = ev["payload"]
+              last_prompt = if payload.is_a?(Hash)
+                              payload["content"] || payload["command"] || payload["raw"] || payload.to_s
+                            else
+                              payload.to_s
+                            end
+              break
+            end
+          end
+        end
+
+        start_time = first_event["ts"] || File.mtime(file).iso8601
+
+        {
+          id: File.basename(file, ".jsonl"),
+          name: File.basename(file),
+          path: file,
+          scope: scope,
+          mtime: File.mtime(file),
+          start_time: start_time,
+          event_count: event_count,
+          last_prompt: (last_prompt || "No prompt")[0..50]
+        }
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rubik/session/recorder.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "time"
+require_relative "../platform"
+require_relative "../security/redactor"
+
+module Rubik
+  module Session
+    class Recorder
+      MASK_PATTERNS = Rubik::Security::Redactor::PATTERNS
+
+      MAX_RECENT_EVENTS = 500
+
+      attr_reader :session_file, :events
+
+      def initialize(sessions_dir: nil, session_name: nil, root_dir: Dir.pwd, home_dir: ENV.fetch("HOME", nil)) # rubocop:disable Lint/UnusedMethodArgument -- arayüz kwarg'i korunuyor
+        @sessions_dir = sessions_dir || File.join(root_dir, ".rubik", "sessions")
+        begin
+          FileUtils.mkdir_p(@sessions_dir)
+        rescue SystemCallError => e
+          warn "[WARN] Failed to create sessions directory #{@sessions_dir}: #{e.message}" if ENV["RUBIK_DEBUG"]
+        end
+
+        filename = session_name || "session_#{Time.now.strftime('%Y%m%d_%H%M%S')}_#{Process.pid}_#{(Time.now.to_f * 1000).to_i % 1000}.jsonl"
+        @session_file = File.join(@sessions_dir, filename)
+        @events = []
+      end
+
+      def record(type, payload)
+        masked_payload = mask_payload(payload)
+        event = {
+          "ts" => Time.now.iso8601,
+          "type" => type.to_s,
+          "payload" => masked_payload
+        }
+
+        push_event(event)
+        File.open(@session_file, "a") do |f|
+          f.puts(Rubik::Platform.safe_json_dump(event))
+        end
+        event
+      end
+
+      def record_user_turn(text)
+        record("user_turn", { "role" => "user", "content" => text })
+      end
+
+      # Plan 61: streamed records whether the text was displayed live as
+      # chunks — session files become diagnosable when someone later asks
+      # "did the answer stream or not?".
+      def record_assistant_response(text, tokens: nil, streamed: nil)
+        payload = { "role" => "assistant", "content" => text, "tokens" => tokens, "streamed" => streamed }.compact
+        record("assistant_response", payload)
+      end
+
+      def record_tool_call(tool_name, args, call_id: nil)
+        payload = { "tool" => tool_name, "args" => args, "call_id" => call_id }.compact
+        record("tool_call", payload)
+      end
+
+      def record_tool_result(tool_name, output, status: :ok, call_id: nil)
+        payload = { "tool" => tool_name, "output" => output, "status" => status, "call_id" => call_id }.compact
+        record("tool_result", payload)
+      end
+
+      def record_repl_command(cmd, output)
+        record("repl_command", { "command" => cmd, "output" => output })
+      end
+
+      def switch_session_file(target_file, cleanup_empty_current: true)
+        if cleanup_empty_current && @session_file && File.exist?(@session_file) && File.expand_path(@session_file) != File.expand_path(target_file)
+          begin
+            lines = File.readlines(@session_file).reject { |l| l.strip.empty? }
+            is_empty_or_only_start = lines.empty? || (lines.size == 1 && (
+              begin
+                ev = JSON.parse(lines.first)
+                ev["type"] == "session_start"
+              rescue JSON::ParserError
+                false
+              end
+            ))
+            File.delete(@session_file) if is_empty_or_only_start
+          rescue StandardError
+            # ignore file cleanup error
+          end
+        end
+
+        @session_file = target_file
+        @events = []
+        if File.exist?(@session_file)
+          File.foreach(@session_file) do |line|
+            next if line.strip.empty?
+
+            begin
+              push_event(JSON.parse(line))
+            rescue JSON::ParserError
+              # ignore malformed line
+            end
+          end
+        end
+
+        record("session_resumed", {
+                 "parent_session_id" => File.basename(target_file, ".jsonl"),
+                 "resumed_at" => Time.now.iso8601
+               })
+      end
+
+      def mask_text(text)
+        Rubik::Security::Redactor.redact(text)
+      end
+
+      def read_history(limit = 20)
+        inputs = @events.select { |e| ["input", "command", "prompt", "user_turn", "repl_command"].include?(e["type"]) }
+        inputs.last(limit)
+      end
+
+      private
+
+      def push_event(event)
+        @events << event
+        @events.shift while @events.size > MAX_RECENT_EVENTS
+        event
+      end
+
+      def mask_payload(payload)
+        case payload
+        when Hash
+          payload.each_with_object({}) do |(k, v), h|
+            key_str = k.to_s
+            is_secret_key = key_str.match?(/(api_key|auth|password|secret|_token\b|^token\b)/i) && !key_str.match?(/(tokens|token_count|max_tokens)/i)
+            h[k] = if is_secret_key
+                     "***MASKED***"
+                   else
+                     mask_payload(v)
+                   end
+          end
+        when Array
+          payload.map { |v| mask_payload(v) }
+        when String
+          mask_text(payload)
+        else
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/rubik/session/replayer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rubik
+  module Session
+    class Replayer
+      DESTRUCTIVE_COMMANDS = ["apply", "sh", "rm", "execute"].freeze
+
+      attr_reader :shell, :replayed_events, :skipped_events
+
+      def initialize(shell)
+        @shell = shell
+        @replayed_events = []
+        @skipped_events = []
+      end
+
+      def replay_file(session_file_path)
+        return false unless File.exist?(session_file_path)
+
+        lines = File.readlines(session_file_path)
+        @shell&.instance_variable_set(:@replaying, true)
+        lines.each do |line|
+          next if line.strip.empty?
+
+          event = begin
+            JSON.parse(line)
+          rescue JSON::ParserError
+            nil
+          end
+          process_event(event) if event
+        end
+        true
+      ensure
+        @shell&.instance_variable_set(:@replaying, false)
+      end
+
+      private
+
+      def process_event(event)
+        type = event["type"]
+        payload = event["payload"]
+
+        return unless ["input", "command"].include?(type)
+
+        cmd_text = payload.is_a?(Hash) ? (payload["raw"] || payload["input"]) : payload.to_s
+
+        if destructive?(cmd_text)
+          @skipped_events << { event: event, reason: "[skipped: destructive]" }
+        else
+          @replayed_events << event
+          @shell.execute_input(cmd_text)
+        end
+      end
+
+      def destructive?(cmd_text)
+        stripped = cmd_text.to_s.strip
+        return false unless stripped.start_with?("!")
+
+        cmd_name = stripped[1..].split(/\s+/, 2).first.to_s.downcase
+        DESTRUCTIVE_COMMANDS.include?(cmd_name)
+      end
+    end
+  end
+end

data/lib/rubik/session.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "session/recorder"
+require_relative "session/replayer"
+require_relative "session/manager"
+
+module Rubik
+  module Session
+  end
+end

data/lib/rubik/skills/frontmatter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Rubik
+  module Skills
+    # Splits a SKILL.md into its YAML frontmatter mapping and markdown body.
+    # Deliberately a hand-rolled fence split + YAML.safe_load — the body is
+    # markdown (frequently containing "---" horizontal rules), so YAML stream
+    # loading would misparse nearly every real skill, and safe_load refuses
+    # object deserialization, keeping the open-trust model honest (a skill
+    # can never instantiate Ruby objects).
+    class Frontmatter
+      class Error < StandardError; end
+
+      # Opening fence must be the first line (spec); the non-greedy body
+      # match stops at the FIRST closing fence, so "---" rules inside the
+      # markdown body are preserved verbatim.
+      FENCE_RE = /\A---[ \t]*\n(.+?)\n---[ \t]*(?:\n|\z)/m
+
+      # => { frontmatter: Hash, body: String }; raises Frontmatter::Error on
+      # any structural problem (caller collects per-skill, never aborts a scan).
+      def self.parse(raw)
+        text = raw.to_s.delete("\r").sub(/\A\uFEFF/, "")
+        match = FENCE_RE.match(text)
+        raise Error, "missing '---' frontmatter fences" unless match
+
+        data = begin
+          YAML.safe_load(match[1])
+        rescue Psych::Exception => e
+          # Psych::Exception subsumes SyntaxError and AliasesNotEnabled
+          # (safe_load refuses aliases and object tags by default).
+          raise Error, "invalid YAML frontmatter: #{e.message}"
+        end
+        raise Error, "frontmatter must be a YAML mapping" unless data.is_a?(Hash)
+
+        { frontmatter: data, body: match.post_match.to_s.lstrip }
+      end
+    end
+  end
+end