memoflow 0.1.0

data/lib/memoflow/provider_context.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Memoflow
+  class ProviderContext
+    def initialize(remote_url:, repo_path:, env: ENV, cli_runner: nil)
+      @remote_url = remote_url.to_s.strip
+      @repo_path = repo_path.to_s
+      @env = env
+      @cli_runner = cli_runner || method(:default_cli_runner)
+    end
+
+    def capture
+      {
+        provider: provider,
+        repository: repository,
+        pull_request: pull_request
+      }.compact
+    end
+
+    private
+
+    def provider
+      return "github" if source_text.include?("github")
+      return "gitlab" if source_text.include?("gitlab")
+      return "bitbucket" if source_text.include?("bitbucket")
+
+      nil
+    end
+
+    def repository
+      @env["GITHUB_REPOSITORY"] || @env["CI_PROJECT_PATH"] || parsed_repository
+    end
+
+    def pull_request
+      payload = github_pull_request || gitlab_merge_request || github_pull_request_from_cli || gitlab_merge_request_from_cli
+      payload if payload && payload[:number]
+    end
+
+    def github_pull_request
+      number = @env["GITHUB_PR_NUMBER"] || @env["PR_NUMBER"]
+      return unless number
+
+      {
+        number: number.to_s,
+        title: @env["GITHUB_PR_TITLE"],
+        body: @env["GITHUB_PR_BODY"],
+        source: "github_env"
+      }
+    end
+
+    def gitlab_merge_request
+      number = @env["CI_MERGE_REQUEST_IID"]
+      return unless number
+
+      {
+        number: number.to_s,
+        title: @env["CI_MERGE_REQUEST_TITLE"],
+        body: @env["CI_MERGE_REQUEST_DESCRIPTION"],
+        source: "gitlab_env"
+      }
+    end
+
+    def parsed_repository
+      cleaned = @remote_url.sub(/\Agit@([^:]+):/, '\1/').sub(%r{\Ahttps?://}, "")
+      parts = cleaned.split("/")
+      return if parts.length < 3
+
+      "#{parts[-2]}/#{parts[-1].sub(/\.git\z/, "")}"
+    end
+
+    def source_text
+      [@remote_url, @env["GITHUB_SERVER_URL"], @env["CI_SERVER_URL"]].compact.join(" ").downcase
+    end
+
+    def github_pull_request_from_cli
+      return unless provider == "github"
+
+      output = run_cli("gh", "pr", "view", "--json", "number,title,body", "--repo", repository.to_s)
+      return unless output
+
+      payload = JSON.parse(output)
+      {
+        number: payload["number"].to_s,
+        title: payload["title"],
+        body: payload["body"],
+        source: "gh_cli"
+      }
+    rescue JSON::ParserError
+      nil
+    end
+
+    def gitlab_merge_request_from_cli
+      return unless provider == "gitlab"
+
+      output = run_cli("glab", "mr", "view", "--output", "json")
+      return unless output
+
+      payload = JSON.parse(output)
+      {
+        number: (payload["iid"] || payload["id"]).to_s,
+        title: payload["title"],
+        body: payload["description"],
+        source: "glab_cli"
+      }
+    rescue JSON::ParserError
+      nil
+    end
+
+    def run_cli(*command)
+      result = @cli_runner.call(command, @repo_path)
+      return unless result[:success]
+
+      result[:output]
+    end
+
+    def default_cli_runner(command, repo_path)
+      output, status = Open3.capture2e(*command, chdir: repo_path)
+      { success: status.success?, output: output }
+    rescue Errno::ENOENT
+      { success: false, output: "" }
+    end
+  end
+end

data/lib/memoflow/server.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Memoflow
+  class Server
+    def initialize(client:, host:, port:)
+      @client = client
+      @host = host
+      @port = port
+      @running = true
+    end
+
+    def start
+      trap_signals
+      @server = TCPServer.new(@host, @port)
+
+      while @running
+        socket = nil
+        begin
+          socket = @server.accept
+          handle(socket)
+        rescue IOError, SystemCallError
+          break unless @running
+        ensure
+          socket&.close
+        end
+      end
+    ensure
+      @server&.close
+    end
+
+    private
+
+    def handle(socket)
+      request_line = socket.gets
+      return unless request_line
+
+      _method, target, _version = request_line.split(" ", 3)
+      consume_headers(socket)
+      path, query = parse_target(target)
+      body = route(path, query)
+      socket.write(response(body))
+    end
+
+    def consume_headers(socket)
+      while (line = socket.gets)
+        break if line == "\r\n"
+      end
+    end
+
+    def parse_target(target)
+      uri = URI.parse(target)
+      query = URI.decode_www_form(uri.query.to_s).to_h
+      [uri.path, query]
+    end
+
+    def route(path, query)
+      payload = case path
+      when "/health"
+        { ok: true, current_task_id: @client.current_task_id }
+      when "/query"
+        @client.query(query["q"], limit: integer_param(query["limit"], 5))
+      when "/context"
+        { packet: @client.context_packet(query: query["q"], limit: integer_param(query["limit"], 5)) }
+      when "/tasks"
+        @client.tasks(limit: 20)
+      else
+        { error: "not_found" }
+      end
+
+      JSON.generate(payload)
+    end
+
+    def response(body)
+      [
+        "HTTP/1.1 200 OK",
+        "Content-Type: application/json",
+        "Content-Length: #{body.bytesize}",
+        "Connection: close",
+        "",
+        body
+      ].join("\r\n")
+    end
+
+    def integer_param(value, default)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      default
+    end
+
+    def trap_signals
+      %w[INT TERM].each do |signal|
+        trap(signal) do
+          @running = false
+          @server&.close
+        end
+      end
+    end
+  end
+end

data/lib/memoflow/store.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Memoflow
+  class Store
+    STATE_DIRS = %w[commits annotations tasks sessions state].freeze
+
+    def initialize(root:, encryptor:)
+      @root = Pathname.new(root)
+      @encryptor = encryptor
+    end
+
+    def setup!
+      STATE_DIRS.each do |dir|
+        FileUtils.mkdir_p(@root.join(dir))
+      end
+    end
+
+    def write_commit(record)
+      write("commits", "#{record.fetch(:sha)}.json.enc", record)
+    end
+
+    def write_annotation(record)
+      write("annotations", "#{record.fetch(:id)}.json.enc", record)
+    end
+
+    def write_task(record)
+      write("tasks", "#{record.fetch(:id)}.json.enc", record)
+    end
+
+    def write_session(record)
+      write("sessions", "#{record.fetch(:id)}.json.enc", record)
+    end
+
+    def write_state(name, record)
+      write("state", "#{name}.json.enc", record)
+    end
+
+    def export_bundle(path)
+      with_lock do
+        payload = {
+          exported_at: Time.now.utc.iso8601,
+          version: Memoflow::VERSION,
+          schema_version: Memoflow::SCHEMA_VERSION,
+          records: read_all,
+          state: read_scope("state")
+        }
+        atomic_write(Pathname.new(path), @encryptor.encrypt(JSON.generate(payload)))
+      end
+    end
+
+    def import_bundle(path)
+      with_lock do
+        payload = JSON.parse(@encryptor.decrypt(File.binread(path)), symbolize_names: true)
+        Array(payload[:records]).each { |record| import_record(record) }
+        Array(payload[:state]).each do |record|
+          name = File.basename(record.fetch(:_scope_name, "current_task"))
+          write_state(name, record.reject { |key, _| key == :_scope_name })
+        end
+      end
+    end
+
+    def prune!(keep_days: nil, max_records: nil)
+      with_lock do
+        removed = []
+        %w[commits annotations tasks sessions].each do |scope|
+          records = Dir[@root.join(scope, "*.enc")].sort
+          if keep_days
+            cutoff = Time.now.utc - (keep_days * 86_400)
+            records.each do |path|
+              entry = read_file(path)
+              timestamp = extract_timestamp(entry)
+              next unless timestamp && timestamp < cutoff
+
+              File.delete(path)
+              removed << path
+            end
+          end
+
+          next unless max_records
+
+          current = Dir[@root.join(scope, "*.enc")].sort_by { |path| extract_timestamp(read_file(path)) || Time.at(0) }
+          overflow = current.length - max_records
+          current.first(overflow).each do |path|
+            next if removed.include?(path)
+
+            File.delete(path)
+            removed << path
+          end
+        end
+
+        removed
+      end
+    end
+
+    def commit?(sha)
+      @root.join("commits", "#{sha}.json.enc").exist?
+    end
+
+    def read_state(name)
+      path = @root.join("state", "#{name}.json.enc")
+      return unless path.exist?
+
+      read_file(path)
+    end
+
+    def read_scope(scope)
+      Dir[@root.join(scope, "*.enc")].sort.map do |path|
+        record = read_file(path)
+        record.merge(_scope_name: File.basename(path, ".json.enc"))
+      end
+    end
+
+    def read_all
+      STATE_DIRS.reject { |scope| scope == "state" }.flat_map { |scope| read_scope(scope) }
+    end
+
+    private
+
+    def write(scope, filename, record)
+      with_lock do
+        setup!
+        path = @root.join(scope, filename)
+        payload = JSON.generate(envelope(record).transform_keys(&:to_s))
+        atomic_write(path, @encryptor.encrypt(payload))
+      end
+    end
+
+    def read_file(path)
+      payload = File.binread(path)
+      migrate_record(JSON.parse(@encryptor.decrypt(payload), symbolize_names: true))
+    end
+
+    def import_record(record)
+      scope =
+        case record[:type]
+        when "commit" then "commits"
+        when "annotation" then "annotations"
+        when "task" then "tasks"
+        when "session" then "sessions"
+        else
+          nil
+        end
+      return unless scope
+
+      key = record[:sha] || record[:id]
+      write(scope, "#{key}.json.enc", record.reject { |field, _| field == :_scope_name })
+    end
+
+    def extract_timestamp(entry)
+      value = entry[:timestamp] || entry[:committed_at] || entry[:updated_at] || entry[:started_at]
+      Time.parse(value) if value
+    rescue ArgumentError
+      nil
+    end
+
+    def envelope(record)
+      record.merge(
+        _schema_version: Memoflow::SCHEMA_VERSION,
+        _stored_at: Time.now.utc.iso8601
+      )
+    end
+
+    def migrate_record(record)
+      return record if record[:_schema_version] == Memoflow::SCHEMA_VERSION
+
+      record.merge(_schema_version: Memoflow::SCHEMA_VERSION)
+    end
+
+    def with_lock
+      setup!
+      File.open(@root.join(".lock"), File::RDWR | File::CREAT, 0o644) do |file|
+        file.flock(File::LOCK_EX)
+        yield
+      ensure
+        file.flock(File::LOCK_UN)
+      end
+    end
+
+    def atomic_write(path, payload)
+      temp_path = path.sub_ext("#{path.extname}.tmp-#{SecureRandom.hex(6)}")
+      File.binwrite(temp_path, payload)
+      File.rename(temp_path, path)
+      path
+    ensure
+      File.delete(temp_path) if temp_path && File.exist?(temp_path)
+    end
+  end
+end

data/lib/memoflow/vectorizer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Memoflow
+  class Vectorizer
+    DIMENSIONS = 128
+
+    class << self
+      def encode(text)
+        vector = Array.new(DIMENSIONS, 0.0)
+        tokens(text).each do |token|
+          bucket = Zlib.crc32(token) % DIMENSIONS
+          vector[bucket] += 1.0
+        end
+
+        normalize(vector)
+      end
+
+      def similarity(left, right)
+        return 0.0 if left.nil? || right.nil?
+        return 0.0 if left.empty? || right.empty?
+
+        left.zip(right).sum { |a, b| a.to_f * b.to_f }
+      end
+
+      def indexable_text(entry)
+        pr = entry[:pull_request] || {}
+        [
+          entry[:summary],
+          entry[:subject],
+          entry[:body],
+          entry[:title],
+          entry[:description],
+          Array(entry[:changed_files]).join(" "),
+          Array(entry[:tags]).join(" "),
+          entry[:task_id],
+          entry[:repository],
+          entry[:provider],
+          pr[:title],
+          pr[:body]
+        ].compact.join(" ")
+      end
+
+      private
+
+      def tokens(text)
+        text.to_s.downcase.scan(/[a-z0-9_\/.-]{2,}/)
+      end
+
+      def normalize(vector)
+        magnitude = Math.sqrt(vector.sum { |value| value * value })
+        return vector if magnitude.zero?
+
+        vector.map { |value| (value / magnitude).round(6) }
+      end
+    end
+  end
+end

data/lib/memoflow/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Memoflow
+  VERSION = "0.1.0"
+  SCHEMA_VERSION = 1
+end

data/lib/memoflow.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "openssl"
+require "open3"
+require "pathname"
+require "securerandom"
+require "shellwords"
+require "socket"
+require "time"
+require "uri"
+require "zlib"
+
+require_relative "memoflow/client"
+require_relative "memoflow/cli"
+require_relative "memoflow/configuration"
+require_relative "memoflow/encryptor"
+require_relative "memoflow/embedding_provider"
+require_relative "memoflow/errors"
+require_relative "memoflow/git_context"
+require_relative "memoflow/hook_installer"
+require_relative "memoflow/provider_context"
+require_relative "memoflow/server"
+require_relative "memoflow/store"
+require_relative "memoflow/vectorizer"
+require_relative "memoflow/version"
+
+module Memoflow
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def client(repo_path: Dir.pwd, env: ENV, embedding_provider: nil)
+      Client.new(configuration: configuration, repo_path: repo_path, env: env, embedding_provider: embedding_provider)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: memoflow
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Iksha Labs
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+description: Memoflow captures git-backed development context and exposes a lightweight
+  query API for AI assistants.
+email:
+- opensource@ikshalabs.com
+executables:
+- memoflow
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/memoflow
+- examples/embedder.rb
+- lib/memoflow.rb
+- lib/memoflow/cli.rb
+- lib/memoflow/client.rb
+- lib/memoflow/configuration.rb
+- lib/memoflow/embedding_provider.rb
+- lib/memoflow/encryptor.rb
+- lib/memoflow/errors.rb
+- lib/memoflow/git_context.rb
+- lib/memoflow/hook_installer.rb
+- lib/memoflow/provider_context.rb
+- lib/memoflow/server.rb
+- lib/memoflow/store.rb
+- lib/memoflow/vectorizer.rb
+- lib/memoflow/version.rb
+homepage: https://github.com/ikshalabs/memoflow
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ikshalabs/memoflow
+  changelog_uri: https://github.com/ikshalabs/memoflow/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Encrypted, compressed repo context for AI coding assistants
+test_files: []