antigravity-sdk 0.5.0 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: effdabdb0588788c4b168749a2578e2e1f07aa877a54bfd80fe1969d42f497d2
-  data.tar.gz: 3debe5e4295f8c2e2bcd4c37ec7ea52ea11a77d034370320d4064b52aa08cc29
+  metadata.gz: 25e15da1171b05a2bcc0be36f79e4f1f6e6e0e6135d520d3776282007071ee05
+  data.tar.gz: 3ddfcb833bb6d1339573b81e5910f33c37cd4113bfb28c753367386f0d67d88e
 SHA512:
-  metadata.gz: 4123cbc798ddbfaa82ea0f854e89adb122491d9a99b52f501c15350401e660109be3ca778b6142720f0259256992dbbb73d4d2371d8bdefcda266bd4d98591cf
-  data.tar.gz: d80349e13c564c74bb81c5c8ba14887f39af36507d03b3c6a5883ed3a885359570210d10b9fc1f8cc3e8a0c193408de176f3316129a58e1d6303352c5527ed01
+  metadata.gz: 70112ba04d101d659b82372f4f49f03a301d9d1e8fb4c89de871ccf2abdee7bed7017b3fe8440eff5c935902f0c545238081d2439e7aff1e4ca5a63d76f87e83
+  data.tar.gz: feb64a14685fefe355772238556f05e27a08aad6f9ad44ae74db4fd0c16e1821eda88f78dbcc24cf990cb90d744139697b06eb883da4fe1f447d67a9d486de7c

data/VERSION

@@ -0,0 +1 @@
+0.5.4

data/lib/antigravity/agent.rb

@@ -5,14 +5,14 @@ module Antigravity
 
     attr_accessor :model, :system_instruction, :api_key
     attr_reader :tools, :skills, :hooks, :sidecars, :client, :logger_guard,
-                :workspace, :connection, :conversation
+                :workspace, :connection, :conversation, :policy, :policies, :born_at
 
     def initialize(model: nil, system_instruction: nil, tools: [],
                    skills: [], policies: [], policy: nil, workspace: nil, auto_logger: true, log_file: nil, &block)
       @model = model || Antigravity.config.default_model
       @api_key = Antigravity.config.api_key
       @system_instruction = system_instruction
-      @workspace = workspace ? File.expand_path(workspace) : nil
+      @workspace = resolve_workspace(workspace)
       @tools = tools.dup
       @skills = []
       @policies = []
@@ -23,6 +23,7 @@ module Antigravity
       @connection = nil
       @conversation = nil
       @connected = false
+      @born_at = Time.now
 
       # Register pre-provided tools into the tool runner
       @tool_runner = ToolRunner.new
@@ -68,6 +69,10 @@ module Antigravity
       end
     end
 
+    def workspace=(path)
+      @workspace = resolve_workspace(path)
+    end
+
     # --- Connection Lifecycle ---
 
     def connect!
@@ -89,9 +94,19 @@ module Antigravity
       )
 
       harness_config = build_harness_config
+
+      # Emit indexing hooks — workspace indexing happens during session init
+      index_t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC) if @workspace
+      hooks.emit(:indexing_start, { workspace: @workspace }) if @workspace
+
       @conversation.initialize_session!(harness_config: harness_config)
       @connected = true
 
+      if @workspace
+        index_elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - index_t0
+        hooks.emit(:indexing_done, { workspace: @workspace, elapsed: index_elapsed.round(2) })
+      end
+
       # Emit session_start hook
       hooks.emit(:session_start, {
         model: @model,
@@ -160,6 +175,21 @@ module Antigravity
       @conversation.session_summary(model: @model)
     end
 
+    # Seconds since agent was created
+    def uptime
+      Time.now - @born_at
+    end
+
+    # Human-readable uptime: "1m 23.4s", "7.3s"
+    def uptime_human
+      secs = uptime
+      if secs >= 60
+        "#{(secs / 60).to_i}m #{(secs % 60).round(1)}s"
+      else
+        "#{secs.round(1)}s"
+      end
+    end
+
     # --- Tool Registration ---
 
     def register_tool(tool_or_name = nil, description: "", &block)
@@ -266,11 +296,11 @@ module Antigravity
     end
 
     def lifecycle_logger_enabled?
-      # Explicit opt-in
-      return true if ENV['ANTIGRAVITY_LIFECYCLE'] == '1'
+      # Explicit opt-in (strip handles trailing spaces in .env files)
+      return true if ENV['ANTIGRAVITY_LIFECYCLE']&.strip == '1'
       # Rails/Rack test or development
-      return true if %w[test development].include?(ENV['RAILS_ENV']&.downcase)
-      return true if %w[test development].include?(ENV['RACK_ENV']&.downcase)
+      return true if %w[test development].include?(ENV['RAILS_ENV']&.strip&.downcase)
+      return true if %w[test development].include?(ENV['RACK_ENV']&.strip&.downcase)
       # Explicit opt-out
       false
     end
@@ -361,8 +391,21 @@ module Antigravity
       skill
     end
 
-    def lifecycle_logger_enabled?
-      ENV['ANTIGRAVITY_LIFECYCLE'] == '1'
+    def resolve_workspace(val)
+      return nil if val.nil? || val == false
+
+      raw_path = case val
+                 when :here, :current, true, '.'
+                   '.'
+                 else
+                   val.to_s
+                 end
+
+      expanded = File.expand_path(raw_path)
+      expanded += '/' unless expanded.end_with?('/')
+
+      $stderr.puts "📁 Setting workspace to \e[34m#{expanded}\e[0m" rescue nil
+      expanded
     end
   end
 end

data/lib/antigravity/connection/binary_fetcher.rb

@@ -87,7 +87,7 @@ module Antigravity
 
           unless wheel
             # Try all versions for the platform
-            versions = data['releases']&.keys&.sort_by { |v| Gem::Version.new(v) rescue v }&.reverse
+            versions = data['releases']&.keys&.sort_by { |v| Gem::Version.correct?(v) ? Gem::Version.new(v) : Gem::Version.new('0') }&.reverse
             versions&.each do |ver|
               files = data.dig('releases', ver) || []
               wheel = files.find { |u| u['filename']&.include?(platform) && u['filename']&.end_with?('.whl') }
@@ -134,7 +134,11 @@ module Antigravity
           # Wheels are just ZIP files. Extract the binary.
           # Look for: google/antigravity/bin/localharness (or language_server)
           extract_dir = Dir.mktmpdir('agy-extract-')
-          system('unzip', '-q', '-o', wheel_path, '-d', extract_dir)
+          success = system('unzip', '-q', '-o', wheel_path, '-d', extract_dir)
+          unless success
+            FileUtils.rm_rf(extract_dir)
+            raise HarnessNotFoundError, "Failed to extract wheel using unzip command"
+          end
 
           # Search for the binary inside (prefer localharness over language_server)
           candidates = Dir.glob("#{extract_dir}/**/localharness") +

data/lib/antigravity/connection/local_connection.rb

@@ -121,8 +121,7 @@ module Antigravity
       end
 
       def perform_handshake!
-        storage_dir = File.join(Dir.tmpdir, "antigravity-ruby-#{$$}")
-        FileUtils.mkdir_p(storage_dir)
+        storage_dir = Dir.mktmpdir('antigravity-ruby-')
 
         # Send InputConfig via stdin
         input_config = Protocol.encode_input_config(

data/lib/antigravity/conversation.rb

@@ -131,10 +131,9 @@ module Antigravity
 
           if step[:textDelta] && !step[:textDelta].empty? && is_model_step && is_target_user && !is_error_step
             text_parts << step[:textDelta]
-            chunk = Message.new(
+            chunk = Chunk.new(
               content: step[:textDelta],
-              role: :assistant,
-              delta: true
+              role: :assistant
             )
             block&.call(chunk)
           end
@@ -170,37 +169,44 @@ module Antigravity
           handle_tool_call(tool_call)
         end
 
-        # Usage update
+        # Usage update — do NOT set seen_any_step here!
+        # usageUpdate can leak from the previous turn and trick the GHI #18
+        # stale-FULLY_IDLE guard into accepting a stale FULLY_IDLE as real.
         if (usage = msg[:usageUpdate])
           update_usage(usage)
-          seen_any_step = true
         end
 
         # Trajectory state: STATE_FULLY_IDLE / STATE_CANCELLED = turn complete (authoritative signal from harness)
-        # GHI #18 FIX: Only honor FULLY_IDLE if we've seen at least one stepUpdate/toolCall/usageUpdate
-        # from this turn, OR if enough time has elapsed (1s) that this can't be a stale leftover.
-        # A stale FULLY_IDLE from a previous turn sitting in the WebSocket buffer was causing
-        # collect_response to return immediately with zero steps/text.
+        # GHI #18 + #24 FIX: Only honor FULLY_IDLE if we've seen at least one stepUpdate or toolCall
+        # (NOT usageUpdate — it leaks across turns) from this turn, OR if enough time has elapsed
+        # (2s) that this can't be a stale leftover. A stale FULLY_IDLE from a previous turn sitting
+        # in the WebSocket buffer was causing collect_response to return immediately with 0B text.
         if (traj = msg[:trajectoryStateUpdate])
-          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - turn_started_at
           if traj[:state].to_s =~ /FULLY_IDLE|CANCELLED/
-            if seen_any_step || elapsed > 1.0
+            if seen_any_step
               finished = true
               finished_at = Time.now
             else
               # Stale FULLY_IDLE — skip it (likely leftover from previous turn or init)
-              @hooks&.emit(:ws_message, { _debug: 'skipped_stale_fully_idle', elapsed: elapsed.round(3) })
+              @hooks&.emit(:ws_message, { _debug: 'skipped_stale_fully_idle', seen_any_step: seen_any_step })
             end
           end
         end
 
         # Stop conditions (in priority order):
-        # 1. Session end — always stop
-        # 2. Model response DONE or trajectory FULLY_IDLE / CANCELLED — turn complete
-        if msg.key?(:sessionEndResponse) || finished
+        # 1. Session end — always hard-stop immediately
+        # 2. Finished (DONE or FULLY_IDLE) WITH text — short drain for trailing usage
+        # 3. Finished WITHOUT text but with steps — model was working (thinking),
+        #    text is likely still in-flight. Drain longer (3s) to catch it. (GHI #24)
+        # 4. Not finished but text started — idle timeout for more text
+        if msg.key?(:sessionEndResponse)
           :stop
+        elsif finished && !text_parts.empty?
+          [:idle_timeout, 0.5]
+        elsif finished && text_parts.empty?
+          # FULLY_IDLE arrived but no text yet — wait longer for trailing text
+          [:idle_timeout, 3.0]
         elsif !text_parts.empty?
-          # If assistant has sent text response, allow 3s idle timeout for trailing metadata
           [:idle_timeout, 3.0]
         end
       end
@@ -241,10 +247,40 @@ module Antigravity
       # Symbolize keys for Ruby kwargs
       kwargs = args.transform_keys(&:to_sym)
 
-      begin
-        result = @tool_runner.execute(tool_name, **kwargs)
-      rescue ToolNotFoundError => e
-        result = { error: e.message }
+      # Emit tool_call hook BEFORE execution
+      @hooks&.emit(:tool_call, { tool_name: tool_name, params: args, tool_id: tool_id })
+
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      policy_check = @hooks ? @hooks.run_pre_tool(tool_name, args) : { allowed: true }
+
+      if !policy_check[:allowed]
+        reason = policy_check[:reason]
+        # Same format as client.rb sidecar emission
+        @hooks&.emit(:tool_blocked, { tool: tool_name, reason: reason })
+        result = "❌ TOOL BLOCKED: #{reason}"
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+        
+        # We run the post_tool hook here as well to satisfy AgentLogger's pairing
+        result = @hooks ? @hooks.run_post_tool(tool_name, args, result) : result
+        @hooks&.emit(:tool_result, { tool_name: tool_name, result: result.to_s, duration: duration, tool_id: tool_id })
+      else
+        begin
+          raw_result = @tool_runner.execute(tool_name, **kwargs)
+          
+          # Run post_tool filters/maskers
+          result = @hooks ? @hooks.run_post_tool(tool_name, args, raw_result) : raw_result
+          
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+
+          # Emit tool_result hook AFTER execution
+          @hooks&.emit(:tool_result, { tool_name: tool_name, result: result.to_s, duration: duration, tool_id: tool_id })
+        rescue ToolNotFoundError => e
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+          result = { error: e.message }
+
+          # Emit tool_error hook on failure
+          @hooks&.emit(:tool_error, { tool_name: tool_name, error: e.message, duration: duration, tool_id: tool_id })
+        end
       end
 
       # Send tool response back (protobuf InputEvent.tool_response format)

data/lib/antigravity/harness.rb

@@ -22,8 +22,7 @@ module Antigravity
         return true
       end
 
-      cmd = "#{@bin_path} --port=#{@port}"
-      @stdin, @stdout, @stderr, wait_thr = Open3.popen3(cmd)
+      @stdin, @stdout, @stderr, wait_thr = Open3.popen3(@bin_path, "--port=#{@port}")
       @pid = wait_thr.pid
 
       at_exit { stop! }

data/lib/antigravity/lifecycle_logger.rb

@@ -20,8 +20,9 @@ module Antigravity
     def self.status_line(agent)
       turns    = agent.turn_count rescue 0
       summary  = agent.session_summary rescue {}
-      tokens   = summary.dig(:tokens, :total) || 0
+      tokens   = summary[:total_tokens] || 0
       tok_str  = tokens > 999 ? "#{(tokens / 1000.0).round(1)}k" : tokens.to_s
+      tok_str  = "🪙#{tok_str}"
       model    = summary[:model] || agent.model || '?'
       conv_id  = (summary[:conversation_id] || '?')[0..7]
 
@@ -54,7 +55,18 @@ module Antigravity
         logger.instance_variable_set(:@session_start_time, Process.clock_gettime(Process::CLOCK_MONOTONIC))
         model = info[:model] || agent.model || '?'
         conv_id = (info[:conversation_id] || '?')[0..11]
-        puts C.gray("🟢 #{C.dim("session_start")} | model=#{C.cyan(model)} | conv=#{C.cyan(conv_id)}")
+        puts C.gray("\n🪝🟢 #{C.dim("session_start")} | model=#{C.cyan(model)} | conv=#{C.cyan(conv_id)}")
+      end
+
+      agent.hooks.on(:indexing_start) do |info|
+        ws = info[:workspace] || '?'
+        puts C.gray("🪝 📂 #{C.dim("indexing")}       | #{C.blue(ws)}")
+      end
+
+      agent.hooks.on(:indexing_done) do |info|
+        ws = info[:workspace] || '?'
+        elapsed = info[:elapsed] ? "#{info[:elapsed]}s" : '?'
+        puts C.gray("🪝 ✅ #{C.dim("indexed")}        | #{C.blue(ws)} | #{C.green(elapsed)}")
       end
 
       agent.hooks.on(:session_end) do |info|
@@ -65,9 +77,9 @@ module Antigravity
                   end
         turns = info[:turn_count] || agent.turn_count rescue 0
         summary = agent.session_summary rescue {}
-        tokens = summary.dig(:tokens, :total) || 0
+        tokens = summary[:total_tokens] || 0
         tok_str = tokens > 999 ? "#{(tokens / 1000.0).round(1)}k" : tokens.to_s
-        puts C.gray("🔴 #{C.dim("session_end")}   | #{C.bold("#{turns} turns")} | #{tok_str} tok | #{elapsed}s")
+        puts C.gray("🪝🔴 #{C.dim("session_end")}   | #{C.bold("#{turns} turns")} | 🪙#{tok_str} | #{elapsed}s")
       end
     end
 
@@ -81,7 +93,7 @@ module Antigravity
         preview = text.to_s[0..60].gsub("\n", ' ')
         preview += '...' if text.to_s.length > 60
         status = self.class.status_line(agent) rescue C.dim("T#{count}")
-        puts C.gray("  ➡️  #{C.dim("pre_turn")}  T#{count} | #{C.yellow("\"#{preview}\"")} | #{status}")
+        puts C.gray("🪝 ➡️  #{C.dim("pre_turn")}  T#{count} | #{C.yellow("\"#{preview}\"")} | #{status}")
       end
 
       agent.hooks.after_response do |response|
@@ -99,12 +111,12 @@ module Antigravity
         tool_count = response.respond_to?(:tool_calls_count) ? (response.tool_calls_count || 0) : 0
         status = self.class.status_line(agent) rescue ''
 
-        parts = ["#{C.green("#{chars}ch")} #{C.dim("#{lines}L")}"]
-        parts << "#{C.magenta("#{thinking_len}ch")} think" if thinking_len > 0
+        parts = ["#{C.green("#{chars}B")} #{C.dim("#{lines}L")}"]
+        parts << "#{C.magenta("#{thinking_len}B")} think" if thinking_len > 0
         parts << "#{C.cyan("#{tool_count}")} tools" if tool_count > 0
         parts << "#{C.blue("#{elapsed}s")}"
 
-        puts C.gray("  ⬅️  #{C.dim("post_turn")} T#{logger.instance_variable_get(:@turn_count)} | #{parts.join(' | ')} | #{status}")
+        puts C.gray("\n🪝 ⬅️  #{C.dim("post_turn")} T#{logger.instance_variable_get(:@turn_count)} | #{parts.join(' | ')} | #{status}")
         if logger.instance_variable_get(:@verbose)
           puts C.dim("     \"#{preview}\"")
         end
@@ -117,28 +129,32 @@ module Antigravity
       agent.hooks.on(:tool_call) do |info|
         name = info[:tool_name] || info[:name] || '?'
         params_preview = (info[:params] || {}).keys.join(', ')
-        puts C.gray("    🔧 #{C.dim("tool_call")}  | #{C.cyan(name)}(#{C.dim(params_preview)})")
+        puts C.gray("  🪝 🔧 #{C.dim("tool_call")}  | #{C.cyan(name)}(#{C.dim(params_preview)})")
       end
 
       agent.hooks.on(:tool_result) do |info|
         name = info[:tool_name] || info[:name] || '?'
-        result_len = info[:result].to_s.length rescue 0
+        result_str = info[:result].to_s
+        result_len = result_str.bytesize rescue 0
+        preview = result_str[0..120].gsub("\n", ' ')
+        preview += '...' if result_str.length > 120
         duration = info[:duration] ? "#{info[:duration].round(2)}s" : nil
-        parts = [C.cyan(name), "#{result_len}ch"]
+        parts = [C.cyan(name), "#{result_len}B"]
         parts << duration if duration
-        puts C.gray("    ✅ #{C.dim("tool_done")}  | #{parts.join(' | ')}")
+        puts C.gray("  🪝 ✅ #{C.dim("tool_done")}  | #{parts.join(' | ')}")
+        puts C.dim("     → #{C.yellow(preview)}") if result_len > 0
       end
 
       agent.hooks.on(:tool_blocked) do |info|
         name = info[:tool] || '?'
         reason = info[:reason] || 'policy'
-        puts C.red("    🚫 #{C.dim("tool_deny")}  | #{C.red(name)} — #{reason}")
+        puts C.red("  🪝 🚫 #{C.dim("tool_deny")}  | #{C.red(name)} — #{reason}")
       end
 
       agent.hooks.on(:tool_error) do |info|
         name = info[:tool_name] || info[:name] || '?'
         error = info[:error] || info[:message] || '?'
-        puts C.red("    💥 #{C.dim("tool_error")} | #{C.red(name)} — #{error.to_s[0..80]}")
+        puts C.red("  🪝 💥 #{C.dim("tool_error")} | #{C.red(name)} — #{error.to_s[0..80]}")
       end
     end
   end

data/lib/antigravity/skill.rb

@@ -71,7 +71,11 @@ module Antigravity
 
       content = File.read(skill_file, encoding: 'UTF-8')
       if content =~ /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
-        front_matter = YAML.safe_load(Regexp.last_match(1)) || {}
+        front_matter = begin
+                         YAML.safe_load(Regexp.last_match(1)) || {}
+                       rescue Psych::SyntaxError => e
+                         raise ArgumentError, "Invalid YAML frontmatter in #{skill_file}: #{e.message}"
+                       end
         @name = front_matter["name"] || File.basename(@path)
         @description = front_matter["description"] || ""
         @metadata = front_matter.fetch("metadata", {})

data/lib/antigravity/version.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
 module Antigravity
-  VERSION = File.read(File.expand_path("../../VERSION", __dir__)).strip rescue "0.1.0"
+  VERSION = begin
+    version_file = [
+      File.expand_path("../../VERSION", __dir__),
+      File.expand_path("../VERSION", __dir__)
+    ].find { |f| File.exist?(f) }
+    version_file ? File.read(version_file).strip : "0.5.0"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: antigravity-sdk
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.4
 platform: ruby
 authors:
 - Riccardo Carlesso
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: An elegant, Ruby-like SDK for building autonomous AI agents with Google
   Antigravity.
 email:
@@ -59,6 +73,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- VERSION
 - lib/antigravity.rb
 - lib/antigravity/agent.rb
 - lib/antigravity/base.rb