adlog-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b2df74409bd05c5dade76e7a839135bf87d620789bb070f9978821d3e8ecf098
+  data.tar.gz: 2bde4eb999917d624821e0a4f7ea48883fe46731ed175c5370d20a0c48d4e361
+SHA512:
+  metadata.gz: f0a0f5d7248039bbddf270c9185e811e9349cef5e876f0bb05f9b249ded2e2d327a17d5dd480e868020adf25197b6c31feabd007bde47e21cac2115b3af7dd25
+  data.tar.gz: 21abdf89682af28a2dad0843242fbf02b16074e3372472757d405519b0aaa07689aca6ac6c7ccf7afb2d0d76add119dfce376929804a77e7f2fe2d74a8e57a0e

data/exe/adlog

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/adlog/cli"
+
+exit Adlog::CLI::Runner.new.run(ARGV)

data/exe/adlog-claude-code-watch

@@ -0,0 +1,389 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# adlog-claude-code-watch: Claude Code セッションログを inotify で監視し、
+# 差分を adlog に append で送信する。
+#
+# SessionStart hook から呼ばれる想定:
+#   stdin から JSON { session_id, transcript_path, cwd } を受け取り、
+#   fork してデーモン化、inotify + pidfd で監視。
+#   Claude プロセス終了で自動停止。
+
+require "json"
+require "fiddle"
+require "fiddle/import"
+require_relative "../lib/adlog/cli"
+
+# ============================================================
+# Linux syscall wrappers
+# ============================================================
+
+module LinuxSys
+  extend Fiddle::Importer
+  dlload "libc.so.6"
+  extern "int inotify_init()"
+  extern "int inotify_add_watch(int, const char*, unsigned int)"
+  extern "int close(int)"
+  extern "int read(int, void*, unsigned int)"
+  extern "long syscall(long, ...)"
+
+  # pidfd_open(2) — Linux 5.3+、glibc ラッパー不要で syscall 直接呼び出し
+  SYS_PIDFD_OPEN = 434 # x86_64
+
+  def self.pidfd_open(pid, flags)
+    syscall(SYS_PIDFD_OPEN, pid, flags).to_i
+  end
+
+  IN_MODIFY   = 0x00000002
+  IN_CREATE   = 0x00000100
+  IN_MOVED_TO = 0x00000080
+end
+
+# ============================================================
+# Claude Code セッション監視デーモン
+# ============================================================
+
+class SessionWatcher
+  SELECT_TIMEOUT = 30 # 秒
+
+  def initialize(db_option:, session_id:, transcript_path:, cwd:, model:, source:, target_pid:)
+    @db_option = db_option
+    @session_id = session_id
+    @transcript_path = transcript_path
+    @cwd = cwd
+    @model = model
+    @source = source
+    @target_pid = target_pid
+    @last_sent_size = 0
+    @tags = build_tags
+  end
+
+  def run
+    daemonize
+    setup_pid_file
+    setup_signals
+
+    $0 = "adlog-claude-code-watch: #{@session_id[0..7]}"
+
+    @pidfd = open_pidfd
+    @inotify_fd, @inotify_io = setup_inotify
+    at_exit { cleanup_fds }
+
+    send_initial_diff
+    main_loop
+  end
+
+  private
+
+  # ---- デーモン化・セットアップ ----
+
+  def daemonize
+    exit 0 if fork
+    Process.setsid
+    $stdin.reopen("/dev/null")
+    $stdout.reopen("/dev/null")
+    $stderr.reopen("/dev/null")
+  end
+
+  def setup_pid_file
+    @pid_file = File.join(ENV["TMPDIR"] || "/tmp", "adlog-cc-watch-#{@session_id}.pid")
+    File.write(@pid_file, Process.pid.to_s)
+    at_exit { File.delete(@pid_file) if File.exist?(@pid_file) }
+  end
+
+  def setup_signals
+    trap("TERM") { exit 0 }
+    trap("INT")  { exit 0 }
+  end
+
+  # ---- pidfd / inotify ----
+
+  def open_pidfd
+    fd = LinuxSys.pidfd_open(@target_pid, 0)
+    at_exit { LinuxSys.close(fd) if fd >= 0 } if fd >= 0
+    fd
+  rescue
+    -1
+  end
+
+  def setup_inotify
+    fd = LinuxSys.inotify_init
+    if fd < 0
+      $stderr.reopen("/dev/stderr") rescue nil
+      $stderr.puts "adlog-claude-code-watch: inotify_init failed"
+      exit 1
+    end
+
+    LinuxSys.inotify_add_watch(
+      fd, File.dirname(@transcript_path),
+      LinuxSys::IN_MODIFY | LinuxSys::IN_CREATE | LinuxSys::IN_MOVED_TO
+    )
+
+    io = IO.for_fd(fd, autoclose: false)
+    [fd, io]
+  end
+
+  def cleanup_fds
+    LinuxSys.close(@pidfd) if @pidfd && @pidfd >= 0
+    LinuxSys.close(@inotify_fd) if @inotify_fd
+  end
+
+  # ---- プロセス生存確認 ----
+
+  def target_alive?
+    Process.kill(0, @target_pid)
+    true
+  rescue Errno::ESRCH
+    false
+  rescue Errno::EPERM
+    # 権限不足でもプロセスは存在する
+    true
+  end
+
+  # ---- メインループ ----
+
+  def send_initial_diff
+    @last_sent_size = send_diff
+  end
+
+  def main_loop
+    pidfd_io = @pidfd >= 0 ? IO.for_fd(@pidfd, autoclose: false) : nil
+    watch_fds = [@inotify_io]
+    watch_fds << pidfd_io if pidfd_io
+    buf = Fiddle::Pointer.malloc(4096)
+
+    loop do
+      readable = IO.select(watch_fds, nil, nil, SELECT_TIMEOUT)
+
+      if readable
+        ready = readable[0]
+
+        # pidfd が readable → Claude プロセス終了
+        if pidfd_io && ready.include?(pidfd_io)
+          finish
+          return
+        end
+
+        # inotify イベント → ファイル差分送信
+        if ready.include?(@inotify_io)
+          LinuxSys.read(@inotify_fd, buf, 4096)
+          @last_sent_size = send_diff
+        end
+      else
+        # タイムアウト: 差分チェック + プロセス生存確認
+        @last_sent_size = send_diff
+        unless target_alive?
+          finish
+          return
+        end
+      end
+    rescue => e
+      # プロセス生存確認をリトライ前にも行う
+      unless target_alive?
+        finish
+        return
+      end
+      sleep 1
+    end
+  end
+
+  # 終了処理: 最終差分送信 + token 集計タグ追加
+  def finish
+    @last_sent_size = send_diff
+
+    total_in, total_out = count_tokens
+    if total_in > 0 || total_out > 0
+      final_tags = @tags + ["tokens_in:#{total_in}", "tokens_out:#{total_out}"]
+      send_tags(tags: final_tags)
+    end
+  end
+
+  # ---- タグ構築 ----
+
+  def build_tags
+    tags = ["session:#{@session_id}"]
+    tags << "cwd:#{@cwd}" if @cwd
+    tags << "model:#{@model}" if @model
+    tags << "source:#{@source}" if @source
+    tags
+  end
+
+  # ---- adlog 送信 ----
+
+  def send_diff
+    return @last_sent_size unless File.exist?(@transcript_path)
+
+    current_size = File.size(@transcript_path)
+    return @last_sent_size if current_size <= @last_sent_size
+
+    diff = File.open(@transcript_path, "rb") do |f|
+      f.seek(@last_sent_size)
+      f.read
+    end
+
+    return @last_sent_size if diff.nil? || diff.empty?
+
+    dir_name = @cwd ? File.basename(@cwd) : nil
+    title = [dir_name, @session_id[0..7]].compact.join(" ")
+
+    argv = [
+      "--append", @session_id,
+      "--type", "claude_code",
+      "--title", title,
+      "-q"
+    ]
+    @tags.each { |t| argv.push("--tag", t) }
+    argv.push("--db", @db_option) if @db_option
+
+    if run_cli(argv, input: diff)
+      current_size
+    else
+      @last_sent_size
+    end
+  rescue
+    @last_sent_size
+  end
+
+  # タグのみ更新（body は空白1文字で append）
+  def send_tags(tags:)
+    argv = ["--append", @session_id, "--type", "claude_code", "-q"]
+    tags.each { |t| argv.push("--tag", t) }
+    argv.push("--db", @db_option) if @db_option
+
+    run_cli(argv, input: " ")
+  rescue
+    nil
+  end
+
+  # CLI を fork して実行
+  def run_cli(argv, input:)
+    runner = Adlog::CLI::Runner.new
+    rd, wr = IO.pipe
+    wr.binmode
+    wr.write(input)
+    wr.close
+
+    pid = fork do
+      $stdin.reopen(rd)
+      rd.close
+      exit runner.run(argv)
+    end
+    rd.close
+    _, status = Process.waitpid2(pid)
+    status.exitstatus == 0
+  end
+
+  # ---- token 集計 ----
+
+  def count_tokens
+    total_in = 0
+    total_out = 0
+    File.foreach(@transcript_path) do |line|
+      obj = JSON.parse(line)
+      usage = obj.dig("message", "usage")
+      if usage
+        total_in += usage["input_tokens"].to_i
+        total_out += usage["output_tokens"].to_i
+      end
+    rescue JSON::ParserError
+      next
+    end
+    [total_in, total_out]
+  rescue
+    [0, 0]
+  end
+end
+
+# ============================================================
+# エントリポイント
+# ============================================================
+
+HELP_TEXT = <<~HELP
+  Usage: adlog-claude-code-watch [--db @user/name]
+
+  Watch a Claude Code session transcript and incrementally send diffs to adlog.
+
+  This command is designed to be called as a Claude Code SessionStart hook.
+  It reads JSON from stdin (provided by Claude Code) containing:
+    - session_id       (required) Unique session identifier
+    - transcript_path  (required) Path to the session transcript file
+    - cwd              (optional) Working directory of the session
+
+  After reading the input, it forks a background daemon that:
+    1. Monitors the transcript file for changes via inotify
+    2. Sends new content to adlog incrementally using append mode
+    3. Automatically exits when the Claude Code process terminates
+
+  Options:
+    --db @user/name    Target database to send logs to (e.g. @ko1/chats)
+    -h, --help         Show this help message
+
+  Setup:
+    Add the following to ~/.claude/settings.json:
+
+      {
+        "hooks": {
+          "SessionStart": [
+            {
+              "matcher": "",
+              "hooks": [
+                {
+                  "type": "command",
+                  "command": "adlog-claude-code-watch --db @user/name"
+                }
+              ]
+            }
+          ]
+        }
+      }
+
+  Requirements:
+    - Linux (uses inotify and pidfd syscalls)
+    - adlog CLI gem installed
+HELP
+
+# オプション引数: --db @user/name
+db_option = nil
+args = ARGV.dup
+while arg = args.shift
+  if arg == "--db" && args.first
+    db_option = args.shift
+  elsif arg == "-h" || arg == "--help"
+    puts HELP_TEXT
+    exit 0
+  end
+end
+
+input = JSON.parse($stdin.read)
+session_id = input["session_id"]
+transcript_path = input["transcript_path"]
+cwd = input["cwd"]
+model = input["model"]
+source = input["source"]
+
+unless session_id && transcript_path
+  $stderr.puts "adlog-claude-code-watch: session_id and transcript_path required (stdin JSON)"
+  exit 1
+end
+
+# 親プロセス（Claude Code）の PID を取得
+# hook は sh -c で実行されるので、grandparent を探す
+target_pid = Process.ppid
+begin
+  comm = File.read("/proc/#{target_pid}/comm").strip
+  if comm =~ /\A(sh|bash|dash|zsh)\z/
+    stat = File.read("/proc/#{target_pid}/stat")
+    target_pid = $1.to_i if stat =~ /\)\s+\S+\s+(\d+)/
+  end
+rescue
+end
+
+SessionWatcher.new(
+  db_option: db_option,
+  session_id: session_id,
+  transcript_path: transcript_path,
+  cwd: cwd,
+  model: model,
+  source: source,
+  target_pid: target_pid
+).run

data/lib/adlog/cli/version.rb

@@ -0,0 +1,5 @@
+module Adlog
+  module CLI
+    VERSION = "0.1.0"
+  end
+end

data/lib/adlog/cli.rb

@@ -0,0 +1,329 @@
+require "net/http"
+require "uri"
+require "json"
+require "optparse"
+require_relative "cli/version"
+
+module Adlog
+  module CLI
+    class UsageError < StandardError; end
+    class AuthError < StandardError; end
+    class HttpError < StandardError; end
+
+    class Runner
+      EXIT_OK      = 0
+      EXIT_USAGE   = 1
+      EXIT_HTTP    = 2
+      EXIT_AUTH    = 3
+
+      def run(argv)
+        options = { tags: [] }
+        files = parse_options!(argv, options)
+
+        auth = resolve_auth(options)
+        scope = resolve_scope(options, auth)
+        entries = build_entries(files, options)
+
+        raise UsageError, "No input provided" if entries.empty?
+
+        base_url = options[:url] || default_url
+
+        entries.each do |entry|
+          if options[:dry_run]
+            print_dry_run(base_url, entry, auth, scope, options)
+          else
+            response = post_ingest(
+              base_url: base_url,
+              token: auth[:token],
+              scope: scope,
+              title: entry[:title],
+              type: options[:type],
+              tags: options[:tags],
+              key: options[:key],
+              ts: entry[:ts],
+              body: entry[:body],
+              timeout: options[:timeout] || 30,
+              verbose: options[:verbose]
+            )
+
+            if response.is_a?(Net::HTTPSuccess)
+              unless options[:quiet]
+                payload = parse_json_response(response)
+                print_entry_url(base_url, scope, payload)
+              end
+            else
+              body = truncate(response.body, 200)
+              $stderr.puts "Error #{response.code}: #{body}"
+              return EXIT_HTTP
+            end
+          end
+        end
+
+        EXIT_OK
+      rescue UsageError => e
+        $stderr.puts "Usage error: #{e.message}"
+        EXIT_USAGE
+      rescue AuthError => e
+        $stderr.puts "Auth error: #{e.message}"
+        EXIT_AUTH
+      rescue HttpError => e
+        $stderr.puts "HTTP error: #{e.message}"
+        EXIT_HTTP
+      end
+
+      private
+
+      # --- Option parsing ---
+
+      def parse_options!(argv, options)
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: adlog [OPTIONS] [FILES...]"
+          o.separator ""
+
+          o.on("--url URL", "Server URL (default: ADLOG_URL or http://localhost:3000)") { |v| options[:url] = v }
+          o.on("--db SCOPE", "DB scope @user/name") { |v| options[:db] = v }
+          o.on("--gha", "Use GitHub Actions OIDC auth") { options[:gha] = true }
+          o.on("--token TOKEN", "Access token (fallback: ADLOG_TOKEN)") { |v| options[:token] = v }
+          o.on("--title TITLE", "Entry title") { |v| options[:title] = v }
+          o.on("--type TYPE", "Entry type (e.g. text/ruby, gha, claude_code)") { |v| options[:type] = v }
+          o.on("--tag TAG", "Tag (repeatable, e.g. --tag repo:ruby/ruby --tag status:ok)") { |v| options[:tags] << v }
+          o.on("--append KEY", "Append to existing entry with KEY, or create new") { |v| options[:key] = v }
+          o.on("--mtime", "Use file mtime as entry timestamp") { options[:mtime] = true }
+          o.on("--timeout SEC", Integer, "HTTP timeout seconds (default: 30)") { |v| options[:timeout] = v }
+          o.on("--dry-run", "Print request summary, don't send") { options[:dry_run] = true }
+          o.on("--verbose", "Print request/response details") { options[:verbose] = true }
+          o.on("-q", "--quiet", "Suppress output on success") { options[:quiet] = true }
+          o.on("-h", "--help", "Show help") { puts o; exit EXIT_OK }
+        end
+        parser.parse!(argv)
+        argv # remaining args are files
+      rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+        raise UsageError, e.message
+      end
+
+      # --- Authentication ---
+
+      def resolve_auth(options)
+        if options[:gha]
+          token = fetch_oidc_token(ENV.fetch("ADLOG_OIDC_AUDIENCE", "adlog"))
+          { type: "oidc", token: token }
+        elsif options[:token]
+          parse_token_option(options)
+        elsif ENV["ADLOG_TOKEN"]
+          { type: "token", token: ENV["ADLOG_TOKEN"] }
+        elsif ENV["ADLOG_TOKENS"]
+          if options[:db]
+            token = select_token_from_env(options[:db])
+            # --db foo → @$USER/foo でも探す
+            if token.nil? && !options[:db].start_with?("@")
+              login = ENV["ADLOG_LOGIN"] || ENV["USER"]
+              if login
+                expanded = "@#{login}/#{options[:db]}"
+                token = select_token_from_env(expanded)
+                options[:db] = expanded if token
+              end
+            end
+            raise AuthError, "No matching token in ADLOG_TOKENS for #{options[:db]}" unless token
+            { type: "token", token: token }
+          else
+            db, token = first_token_from_env
+            raise AuthError, "ADLOG_TOKENS is empty" unless db
+            options[:db] = db
+            { type: "token", token: token }
+          end
+        else
+          raise AuthError, "No authentication provided. Use --token, --gha, or set ADLOG_TOKEN"
+        end
+      end
+
+      def parse_token_option(options)
+        val = options[:token]
+        # db:token format (last colon splits token from db)
+        if val.start_with?("@") && val.include?(":")
+          last_colon = val.rindex(":")
+          db = val[0...last_colon]
+          token = val[(last_colon + 1)..]
+          raise UsageError, "--db and db:token format cannot both be specified" if options[:db]
+          options[:db] = db
+          { type: "token", token: token }
+        else
+          { type: "token", token: val }
+        end
+      end
+
+      def select_token_from_env(db_name)
+        parse_tokens_env.each do |key, val|
+          return val if key == db_name
+        end
+        nil
+      end
+
+      def first_token_from_env
+        parse_tokens_env.first
+      end
+
+      def parse_tokens_env
+        ENV["ADLOG_TOKENS"].split(",").filter_map do |pair|
+          last_colon = pair.rindex(":")
+          next unless last_colon
+          key = pair[0...last_colon].strip
+          val = pair[(last_colon + 1)..].strip
+          [key, val]
+        end
+      end
+
+      def fetch_oidc_token(audience)
+        request_url = ENV["ACTIONS_ID_TOKEN_REQUEST_URL"]
+        request_token = ENV["ACTIONS_ID_TOKEN_REQUEST_TOKEN"]
+        raise AuthError, "ACTIONS_ID_TOKEN_REQUEST_URL not set (not running in GitHub Actions?)" unless request_url
+        raise AuthError, "ACTIONS_ID_TOKEN_REQUEST_TOKEN not set" unless request_token
+
+        url = append_audience(request_url, audience)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        req = Net::HTTP::Get.new(uri)
+        req["Authorization"] = "Bearer #{request_token}"
+        resp = http.request(req)
+
+        raise AuthError, "OIDC token fetch failed: #{resp.code}" unless resp.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(resp.body)
+        data["value"] || raise(AuthError, "OIDC response missing 'value'")
+      end
+
+      def append_audience(request_url, audience)
+        sep = request_url.include?("?") ? "&" : "?"
+        "#{request_url}#{sep}audience=#{audience}"
+      end
+
+      # --- Scope ---
+
+      def resolve_scope(options, auth)
+        if options[:db]
+          options[:db]
+        elsif auth[:type] == "oidc"
+          nil # server derives from OIDC claim
+        else
+          login = ENV["ADLOG_LOGIN"] || ENV["USER"]
+          raise UsageError, "Cannot determine DB scope. Use --db or set ADLOG_LOGIN" unless login
+          "@#{login}/inbox"
+        end
+      end
+
+      # --- Entry building ---
+
+      def build_entries(files, options)
+        if files.empty?
+          if $stdin.tty?
+            raise UsageError, "No files specified and stdin is a terminal. Pipe data or pass file arguments."
+          end
+          body = $stdin.binmode.read
+          [{
+            body: body,
+            title: options[:title] || (options[:key] ? nil : "<STDIN>"),
+            ts: nil
+          }]
+        else
+          files.map do |path|
+            raise UsageError, "File not found: #{path}" unless File.exist?(path)
+            body = File.binread(path)
+            ts = options[:mtime] ? (File.mtime(path).to_f * 1000).to_i : nil
+            {
+              body: body,
+              title: options[:title] || File.basename(path),
+              ts: ts
+            }
+          end
+        end
+      end
+
+      # --- HTTP ---
+
+      def post_ingest(base_url:, token:, scope:, title:, type:, tags:, key:, ts:, body:, timeout:, verbose:)
+        uri = build_ingest_uri(base_url, scope: scope, title: title, type: type, tags: tags, key: key, ts: ts)
+
+        if verbose
+          $stderr.puts "POST #{uri}"
+          $stderr.puts "Content-Length: #{body.bytesize}"
+        end
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = timeout
+        http.open_timeout = timeout
+
+        req = Net::HTTP::Post.new(uri)
+        req["Authorization"] = "Bearer #{token}"
+        req["Content-Type"] = "text/plain"
+        req.body = body
+
+        resp = http.request(req)
+
+        if verbose
+          $stderr.puts "Response: #{resp.code}"
+          $stderr.puts resp.body
+        end
+
+        resp
+      end
+
+      def build_ingest_uri(base_url, scope:, title:, type:, tags:, key:, ts:)
+        uri = URI.parse("#{base_url}/api/ingest")
+        params = {}
+        params["db"] = scope if scope
+        params["title"] = title if title
+        params["type"] = type if type
+        params["tags"] = tags.join(",") if tags && !tags.empty?
+        params["append"] = key if key
+        params["ts"] = ts.to_s if ts
+        uri.query = URI.encode_www_form(params) unless params.empty?
+        uri
+      end
+
+      # --- Output ---
+
+      def print_entry_url(base_url, scope, payload)
+        db = payload["db"] || scope
+        id = payload["id"]
+        if db
+          # @user/name -> /@user/name/entries/:id
+          puts "#{base_url}/#{db}/entries/#{id}"
+        else
+          puts "#{base_url}/entries/#{id}"
+        end
+      end
+
+      def print_dry_run(base_url, entry, auth, scope, options)
+        puts JSON.pretty_generate({
+          url: build_ingest_uri(base_url, scope: scope, title: entry[:title], type: options[:type], tags: options[:tags], key: options[:key], ts: entry[:ts]).to_s,
+          auth: auth[:type],
+          db: scope,
+          title: entry[:title],
+          type: options[:type],
+          tags: options[:tags],
+          size_bytes: entry[:body].bytesize,
+          ts: entry[:ts]
+        })
+      end
+
+      def parse_json_response(response)
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        {}
+      end
+
+      # --- Helpers ---
+
+      def default_url
+        ENV.fetch("ADLOG_URL", "https://log.atdot.net")
+      end
+
+      def truncate(str, max)
+        return str if str.nil? || str.length <= max
+        str[0...max] + "..."
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: adlog-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ko1
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Upload text, logs, and conversations to adlog from the command line or
+  GitHub Actions.
+executables:
+- adlog
+- adlog-claude-code-watch
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/adlog
+- exe/adlog-claude-code-watch
+- lib/adlog/cli.rb
+- lib/adlog/cli/version.rb
+homepage: https://github.com/ko1/adlog
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: CLI for adlog - private searchable text store
+test_files: []