pikuri-core 0.0.5 → 0.0.6

data/lib/pikuri/tool/calculator.rb

@@ -1,63 +1,235 @@
 # frozen_string_literal: true
 
-require 'dentaku'
-
 module Pikuri
   class Tool
-    # Evaluates a basic arithmetic expression using Dentaku, with light
-    # preprocessing so the LLM can emit Python-flavored syntax (notably
-    # +**+ for exponentiation) instead of learning Dentaku's dialect.
+    # Evaluates a basic arithmetic expression with Python operator
+    # syntax and semantics, via the hand-rolled recursive-descent
+    # {Parser} below.
+    #
+    # Why hand-rolled rather than a gem: the previous backend, dentaku,
+    # pulled in concurrent-ruby (~16k lines of Ruby — the single
+    # heaviest audit item in pikuri's whole dependency closure) plus
+    # bigdecimal and tsort, all to evaluate four-function arithmetic.
+    # The ~100 lines here implement Python's expression grammar
+    # directly, which also retires the old preprocessing step that
+    # rewrote Python's +**+ into dentaku's +^+ dialect — the model's
+    # native syntax is now simply the grammar.
     #
-    # Scope is intentionally narrow: operators (+, -, *, /, **, %),
-    # parentheses, and decimal numbers. No variables, functions, or
-    # booleans — those would mean teaching the model a dialect, which we
-    # specifically want to avoid for this tool.
+    # Scope is intentionally narrow: operators (+, -, *, /, //, %, **),
+    # unary minus, parentheses, and integer / decimal / e-notation
+    # literals. No variables, functions, or booleans — those would mean
+    # teaching the model a dialect, which we specifically want to avoid
+    # for this tool.
     module Calculator
-      # Translate the operator differences between Python and Dentaku. In
-      # practice that is only +**+ → +^+; everything else in the supported
-      # subset is byte-identical.
-      #
-      # @param expression [String] raw expression as the model wrote it
-      # @return [String] expression with Python-style operators rewritten
-      def self.normalize(expression)
-        expression.gsub('**', '^')
-      end
+      # Raised internally for anything {.calculate} should hand back to
+      # the model as an +"Error: ..."+ observation rather than crash
+      # the agent loop: parse failures, division by zero, complex or
+      # non-finite results. The message always names the offending
+      # token or operands.
+      class Error < StandardError; end
 
-      # Evaluate +expression+ and return the result formatted as a String.
-      # Parse, unbound-variable, and division-by-zero failures are caught
-      # and returned as +"Error: ..."+ strings so the model can read the
-      # failure as the next observation and self-correct rather than
-      # crashing the agent loop.
+      # Evaluate +expression+ and return the result formatted as a
+      # String. Parse and arithmetic failures (division by zero,
+      # overflow to infinity, complex results) are caught and returned
+      # as +"Error: ..."+ strings so the model can read the failure as
+      # the next observation and self-correct rather than crashing the
+      # agent loop.
       #
-      # @param expression [String]
+      # @param expression [String] Python-syntax arithmetic expression
       # @return [String] numeric result, or +"Error: ..."+ on failure
       def self.calculate(expression)
-        result = Dentaku::Calculator.new.evaluate!(normalize(expression))
+        result = Parser.new(expression).parse
+        if result.is_a?(Float) && !result.finite?
+          raise Error, "result of #{expression.inspect} is not a finite number"
+        end
+
         format_result(result)
-      rescue Dentaku::ZeroDivisionError, ZeroDivisionError
-        'Error: division by zero'
-      rescue Dentaku::Error => e
+      rescue Error => e
         "Error: #{e.message}"
       end
 
-      # Dentaku returns BigDecimal for any expression that touches division
-      # or a decimal literal, with full BigDecimal precision (47-digit tails
-      # for the leopard expression). Round to 3 places and strip the
-      # default scientific-notation formatting so the model sees a short
-      # readable number; integer/other results pass through unchanged.
+      # Integers (never produced by division — +/+ is Python-3-style
+      # true division) pass through exact. Floats are rounded to 3
+      # places so the model sees a short readable number, and
+      # whole-valued floats drop the trailing +.0+ (+4 / 2+ renders as
+      # +"2"+, not +"2.0"+).
       def self.format_result(result)
-        case result
-        when BigDecimal then result.round(3).to_s('F')
-        else result.to_s
-        end
+        return result.to_s if result.is_a?(Integer)
+
+        rounded = result.round(3)
+        rounded == rounded.truncate ? rounded.truncate.to_s : rounded.to_s
       end
       private_class_method :format_result
+
+      # Recursive-descent parser-evaluator for Python's arithmetic
+      # expression grammar:
+      #
+      #   additive       := multiplicative (('+' | '-') multiplicative)*
+      #   multiplicative := unary (('*' | '/' | '//' | '%') unary)*
+      #   unary          := ('+' | '-') unary | power
+      #   power          := atom ('**' unary)?
+      #   atom           := NUMBER | '(' additive ')'
+      #
+      # The +power+ → +unary+ recursion on the right operand is what
+      # makes +**+ right-associative (+2**3**2+ is 512) and lets a sign
+      # follow it (+2**-3+); +unary+ sitting *above* +power+ on the
+      # left is what makes +-2**2+ evaluate to -4 — both exactly as
+      # Python parses them.
+      #
+      # Semantics follow Python 3 where Ruby differs: +/+ is always
+      # true (float) division, +//+ floors, +2**-1+ is the Float 0.5
+      # (Ruby would return a Rational), and a negative base under a
+      # fractional exponent is rejected (Ruby would return a Complex).
+      class Parser
+        # One number or operator. +**+ / +//+ listed before their
+        # single-character prefixes so the two-character operators win;
+        # number literals cover +42+, +4.2+, +5.+, +.5+, and e-notation
+        # on any of them. +\G+ anchors each match at the scan position
+        # so nothing between tokens goes unnoticed.
+        TOKEN_RE = %r{\G\s*(\*\*|//|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?|[-+*/%()])}
+
+        # @param expression [String] raw expression as the model wrote it
+        # @raise [Error] when +expression+ contains a character no token matches
+        def initialize(expression)
+          @tokens = tokenize(expression)
+          @pos = 0
+        end
+
+        # Parse and evaluate the whole token stream.
+        #
+        # @return [Integer, Float] the value of the expression
+        # @raise [Error] on syntax errors, division by zero, or a complex result
+        def parse
+          value = additive
+          raise Error, "unexpected #{peek.inspect} after expression" if peek
+
+          value
+        end
+
+        private
+
+        # @param expression [String]
+        # @return [Array<String>] token strings in source order
+        def tokenize(expression)
+          tokens = []
+          pos = 0
+          while (match = TOKEN_RE.match(expression, pos))
+            tokens << match[1]
+            pos = match.end(0)
+          end
+          rest = expression[pos..].to_s.strip
+          raise Error, "unexpected character #{rest[0].inspect} in #{expression.inspect}" unless rest.empty?
+
+          tokens
+        end
+
+        def additive
+          value = multiplicative
+          while (op = accept('+', '-'))
+            rhs = multiplicative
+            value = op == '+' ? value + rhs : value - rhs
+          end
+          value
+        end
+
+        def multiplicative
+          value = unary
+          while (op = accept('*', '/', '//', '%'))
+            value = apply_multiplicative(op, value, unary)
+          end
+          value
+        end
+
+        def unary
+          op = accept('+', '-')
+          return power unless op
+
+          value = unary
+          op == '-' ? -value : value
+        end
+
+        def power
+          base = atom
+          return base unless accept('**')
+
+          apply_power(base, unary)
+        end
+
+        def atom
+          return parenthesized if accept('(')
+
+          token = peek
+          unless token&.match?(/\A[.\d]/)
+            raise Error, token ? "unexpected #{token.inspect}" : 'unexpected end of expression'
+          end
+
+          @pos += 1
+          token.match?(/[.eE]/) ? token.to_f : token.to_i
+        end
+
+        def parenthesized
+          value = additive
+          raise Error, 'missing closing parenthesis' unless accept(')')
+
+          value
+        end
+
+        # @return [String, nil] the next token without consuming it
+        def peek
+          @tokens[@pos]
+        end
+
+        # Consume and return the next token if it is one of +expected+.
+        #
+        # @return [String, nil] the consumed token, or nil on no match
+        def accept(*expected)
+          token = peek
+          return nil unless expected.include?(token)
+
+          @pos += 1
+          token
+        end
+
+        # +/+ is Python-3 true division (always Float); +//+ floors
+        # (kept exact in Ruby's arbitrary-precision Integer division
+        # when both operands are Integers — Ruby's +Integer#/+ already
+        # floors like Python's +//+); +%+ delegates to Ruby's +%+,
+        # whose sign-of-divisor semantics match Python's exactly.
+        def apply_multiplicative(op, lhs, rhs)
+          return lhs * rhs if op == '*'
+          raise Error, 'division by zero' if rhs.zero?
+
+          case op
+          when '/' then lhs.fdiv(rhs)
+          when '//' then lhs.is_a?(Integer) && rhs.is_a?(Integer) ? lhs / rhs : lhs.fdiv(rhs).floor
+          when '%' then lhs % rhs
+          end
+        end
+
+        # Two Python-compatibility shims over Ruby's +**+: an Integer
+        # raised to a negative Integer yields a Float (Ruby would
+        # return a Rational), and a Complex result — negative base
+        # under a fractional exponent — is rejected loudly.
+        def apply_power(base, exponent)
+          if base.is_a?(Integer) && exponent.is_a?(Integer) && exponent.negative?
+            raise Error, 'division by zero' if base.zero?
+
+            return base.to_f**exponent
+          end
+          result = base**exponent
+          if result.is_a?(Complex)
+            raise Error, "(#{base})**(#{exponent}) is a complex number; only real arithmetic is supported"
+          end
+
+          result
+        end
+      end
     end
 
     # Arithmetic-evaluation tool backed by {Tool::Calculator.calculate}.
-    # Accepts Python-flavored operator syntax (+, -, *, /, ** for
-    # exponentiation, %, parentheses, decimals) so the model can emit the
-    # syntax it already knows.
+    # Accepts Python expression syntax (+, -, *, /, //, %, ** for
+    # exponentiation, unary minus, parentheses, decimals) so the model
+    # can emit the syntax it already knows.
     #
     # @return [Tool]
     CALCULATOR = new(
@@ -67,7 +239,7 @@ module Pikuri
 
         Usage:
         - Use this for any arithmetic beyond simple mental math — do not eyeball multi-digit work.
-        - Operators supported: +, -, *, /, ** (exponentiation), %, parentheses, decimal numbers.
+        - Python expression syntax: +, -, *, / (true division), // (floor division), % (modulo), ** (exponentiation), unary minus, parentheses, decimal numbers.
         - Decimal results are rounded to 3 places; integer results are exact.
         - Failures (parse error, division by zero) come back as "Error: ..." — read the message and re-call with a corrected expression.
       DESC

data/lib/pikuri/tool/fetch.rb

@@ -3,13 +3,14 @@
 module Pikuri
   class Tool
     # Truncation policy and Tool spec for the +fetch+ tool. The HTTP work
-    # lives in {Tool::Scraper::Simple.fetch}; this module is a thin
+    # lives in {Tool::Scraper.fetch}; this module is a thin
     # wrapper that accepts only textual content-types, applies a character
     # cap so the LLM doesn't drown in long-form bodies, and exposes the
     # result to the agent loop in OpenAI tool-call shape.
     #
-    # Sister of {Tool::WebScrape}, but without HTML→Markdown or PDF→text
-    # extraction: bodies are returned verbatim. Useful for raw textual
+    # Sister of {Tool::WebScrape}, but with no extraction pass
+    # (HTML→Markdown, or whatever plug-in extractors are registered):
+    # bodies are returned verbatim. Useful for raw textual
     # data — JSON APIs, CSV files, +robots.txt+, sitemaps, source files —
     # where any rendering pass would corrupt the payload.
     module Fetch
@@ -56,7 +57,7 @@ module Pikuri
         CACHE
       end
 
-      # Download +url+ via {Tool::Scraper::Simple.fetch} and return the
+      # Download +url+ via {Tool::Scraper.fetch} and return the
       # response body verbatim, provided the content-type is one we deem
       # textual (any +text/*+, plus the formats listed in
       # {TEXTUAL_APPLICATION_TYPES}). Anything else — PDFs, images, other
@@ -100,16 +101,16 @@ module Pikuri
       #   redirect-loop exhaustion, missing +Location+ on a 3xx, or a
       #   non-textual content-type
       def self.download(url)
-        fetched = Scraper::Simple.fetch(url)
+        fetched = Scraper.fetch(url)
         return fetched.body if textual?(fetched.content_type)
 
         raise Scraper::FetchError,
               "refused to fetch #{url}: content-type #{fetched.content_type.inspect} " \
-              'is not textual (use web_scrape for PDFs or rendered pages)'
+              'is not textual (use web_scrape for rendered pages)'
       end
 
       # @param content_type [String] normalized content-type (no +charset+
-      #   parameter, lowercased) as produced by {Scraper::Simple.fetch}
+      #   parameter, lowercased) as produced by {Scraper.fetch}
       # @return [Boolean] true when the content-type is +text/*+ or one
       #   of {TEXTUAL_APPLICATION_TYPES}
       def self.textual?(content_type)
@@ -138,7 +139,7 @@ module Pikuri
     # Verbatim URL download tool. Thin wrapper over {Tool::Fetch.fetch}
     # that exposes it to the agent loop in OpenAI tool-call shape. Use for
     # raw textual payloads (JSON APIs, CSV files, +robots.txt+, source
-    # files); use {Tool::WEB_SCRAPE} for rendered web pages or PDFs where
+    # files); use {Tool::WEB_SCRAPE} for rendered web pages where
     # readability extraction makes the result usable.
     #
     # @return [Tool]
@@ -149,7 +150,7 @@ module Pikuri
 
         Usage:
         - Use for raw textual payloads: JSON APIs, CSV files, robots.txt, sitemaps, source files — anywhere a rendering pass would corrupt the data.
-        - For rendered HTML pages or PDFs, use web_scrape — it extracts readable content; fetch returns the raw HTML/PDF bytes unchanged.
+        - For rendered HTML pages, use web_scrape — it extracts readable content; fetch returns the raw HTML bytes unchanged.
         - Accepts text/* and common textual application/* types (JSON, XML, JS, XHTML, RSS, Atom). Refuses PDFs, images, and other binaries.
       DESC
       parameters: Parameters.build { |p|

data/lib/pikuri/tool/scraper.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'stringio'
+require 'uri'
+
+module Pikuri
+  class Tool
+    # HTTP side of the web tools ({Tool::WEB_SCRAPE} and {Tool::FETCH}):
+    # GET the URL with a real-browser User-Agent, follow redirects, and
+    # hand the response body to {Pikuri::Extractor.extract} with the
+    # response's +Content-Type+ as the hint. HTML/XHTML render via
+    # {Extractor::HTML}, any other +text/*+ type passes through
+    # verbatim, and plug-in extractors extend the set (with pikuri-pdf
+    # registered, +application/pdf+ extracts — by header or by +%PDF-+
+    # magic, so a PDF served under a lying header still works); the
+    # remaining types raise {FetchError} so the LLM observes the
+    # failure instead of receiving an empty rendering.
+    #
+    # Split into a thin HTTP fetch ({.fetch}) and the extraction
+    # wrapper ({.visit}) so tests can drive each piece in isolation and
+    # {Tool::Fetch} can reuse the HTTP half without the extraction
+    # pass. Nothing here knows about the LLM; the tools that wrap this
+    # module own caching and truncation and turn rendered Markdown (or
+    # {FetchError}) into the next observation.
+    module Scraper
+      # Raised when a URL cannot be rendered into Markdown text — HTTP
+      # non-2xx, network failure, redirect-loop, missing +Location+,
+      # unsupported content-type, or a parse failure that reads as "try
+      # a different URL" to the LLM. Catching this in
+      # {Tool::WEB_SCRAPE} / {Tool::FETCH} turns the failure into an
+      # +"Error: ..."+ observation; anything else bubbles up so genuine
+      # bugs stay visible.
+      class FetchError < StandardError; end
+
+      # @return [String] User-Agent sent with each request; many sites
+      #   reject requests with no UA or an obvious bot UA
+      USER_AGENT = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 ' \
+                   '(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+      # @return [String] +Accept+ header sent with each request, so
+      #   servers that content-negotiate hand back something we can use:
+      #   rendered HTML first, +application/pdf+ for hosts with a PDF
+      #   extractor registered, then any +text/*+ for the verbatim
+      #   pass-through arm.
+      ACCEPT = 'text/html,application/xhtml+xml,application/pdf,text/*;q=0.8'
+      # @return [Integer] maximum number of HTTP redirects to follow
+      #   before giving up
+      MAX_REDIRECTS = 5
+      # @return [Integer] connect timeout in seconds for the underlying
+      #   Faraday request
+      OPEN_TIMEOUT = 10
+      # @return [Integer] read timeout in seconds for the underlying
+      #   Faraday request
+      READ_TIMEOUT = 20
+
+      # @return [Integer] maximum number of characters of an error
+      #   response body to include in a {FetchError} message. The body is
+      #   often a multi-kilobyte HTML challenge page (Cloudflare, WAF
+      #   interstitial, etc.); a short excerpt tells the LLM what kind of
+      #   page came back without flooding the next observation.
+      ERROR_BODY_EXCERPT = 200
+
+      # Result of a successful {Scraper.fetch}: the response body, the
+      # normalized content-type (lower-cased, with any +; charset=...+
+      # parameters stripped), and the final URL after redirects.
+      Fetched = Data.define(:body, :content_type, :url)
+
+      # Fetch +url+ and render its main content as Markdown.
+      #
+      # No caching here — every call hits the network. Callers that want
+      # to memoize results should wrap this method themselves (see
+      # {Tool::WebScrape.visit}, which does exactly that).
+      #
+      # The extracted output is +String#strip+'d so the LLM never sees
+      # a body that opens or closes with blank lines — common with
+      # extracted PDFs' page-feed whitespace and with text bodies that
+      # carry a trailing newline. Interior whitespace is preserved
+      # because Markdown paragraph breaks and source-code indentation
+      # are load-bearing.
+      #
+      # @param url [String] absolute HTTP(S) URL of the page to download
+      # @return [String] full Markdown representation of the page with
+      #   leading/trailing whitespace trimmed, uncapped otherwise —
+      #   caller is responsible for any size limiting before feeding
+      #   the result back to the LLM
+      # @raise [FetchError] on HTTP non-2xx, network failure, redirect
+      #   loop, a 3xx without a +Location+ header, a response no
+      #   extractor recognizes, or an extraction failure (malformed
+      #   PDF, ...)
+      def self.visit(url)
+        extract(fetch(url)).strip
+      end
+
+      # Render a {Fetched} response as Markdown via
+      # {Pikuri::Extractor.extract}, re-raising both extraction failure
+      # modes as {FetchError} — the single exception type the web tools
+      # rescue. The content-type is passed verbatim (including the +""+
+      # of a missing header, which matches no text arm — a body without
+      # transport metadata is refused, not sniffed; only a strong magic
+      # sniff like pikuri-pdf's +%PDF-+ overrides a wrong or missing
+      # header, because such a sniff never misfires on text).
+      #
+      # @param fetched [Fetched]
+      # @return [String] Markdown representation produced by the
+      #   matched extractor
+      # @raise [FetchError] when no extractor matches the response's
+      #   content-type, or when extraction fails
+      def self.extract(fetched)
+        Pikuri::Extractor.extract(StringIO.new(fetched.body), content_type: fetched.content_type)
+      rescue Pikuri::Extractor::Unsupported
+        raise FetchError, "unsupported content-type #{fetched.content_type.inspect} for #{fetched.url}"
+      rescue Pikuri::Extractor::Error => e
+        raise FetchError, e.message
+      end
+
+      # Download the body of +url+, manually following up to
+      # {MAX_REDIRECTS} redirects. Faraday is configured with no
+      # middleware so behavior here mirrors the rest of the codebase
+      # (see +Tool::Search::DuckDuckGo.search+).
+      #
+      # All recoverable failures — HTTP 4xx/5xx, +Faraday::Error+ network
+      # blips, exhausted redirect budget, 3xx without a +Location+ —
+      # surface as {FetchError} so the caller has a single exception type
+      # to rescue. Error bodies are trimmed to {ERROR_BODY_EXCERPT}
+      # characters with whitespace collapsed, so a Cloudflare-challenge
+      # response doesn't dump kilobytes of inline HTML into the next LLM
+      # observation.
+      #
+      # @param url [String] absolute HTTP(S) URL to fetch
+      # @param limit [Integer] redirects remaining; recurses with
+      #   +limit - 1+ on each 3xx
+      # @return [Fetched] body, normalized content-type, and final URL
+      #   after redirects
+      # @raise [FetchError] on non-2xx/3xx responses, network errors,
+      #   redirect-loop exhaustion, or 3xx without a +Location+ header
+      def self.fetch(url, limit: MAX_REDIRECTS)
+        raise FetchError, "too many redirects fetching #{url}" if limit.zero?
+
+        response = begin
+          Faraday.new(request: { open_timeout: OPEN_TIMEOUT, timeout: READ_TIMEOUT }).get(url) do |req|
+            req.headers['User-Agent'] = USER_AGENT
+            req.headers['Accept']     = ACCEPT
+          end
+        rescue Faraday::Error => e
+          raise FetchError, "#{e.class.name.split('::').last} fetching #{url}: #{e.message}"
+        end
+
+        case response.status
+        when 200..299
+          Fetched.new(body: response.body, content_type: normalize_content_type(response.headers['content-type']), url: url)
+        when 300..399
+          location = response.headers['location']
+          raise FetchError, "HTTP #{response.status} from #{url} with no Location header" if location.nil? || location.empty?
+
+          fetch(URI.join(url, location).to_s, limit: limit - 1)
+        else
+          raise FetchError, "HTTP #{response.status} fetching #{url}: #{excerpt(response.body)}"
+        end
+      end
+
+      # Lower-case +raw+ and strip any +; charset=...+ parameters so the
+      # extractors can match on a canonical token.
+      #
+      # @param raw [String, nil] raw +Content-Type+ header value
+      # @return [String] normalized content-type, or +""+ when the
+      #   header was missing
+      def self.normalize_content_type(raw)
+        raw.to_s.split(';').first.to_s.strip.downcase
+      end
+      private_class_method :normalize_content_type
+
+      # Whitespace-collapse +body+ and clip to {ERROR_BODY_EXCERPT}
+      # characters, so the {FetchError} message stays a single readable
+      # line even when the server returned a multi-KB HTML challenge
+      # page.
+      #
+      # @param body [String, nil]
+      # @return [String]
+      def self.excerpt(body)
+        text = body.to_s.gsub(/\s+/, ' ').strip
+        text.length > ERROR_BODY_EXCERPT ? "#{text[0, ERROR_BODY_EXCERPT]}..." : text
+      end
+      private_class_method :excerpt
+    end
+  end
+end

data/lib/pikuri/tool/web_scrape.rb

@@ -3,7 +3,7 @@
 module Pikuri
   class Tool
     # Truncation policy and Tool spec for the +web_scrape+ tool. The actual
-    # scraping lives in {Tool::Scraper::Simple}; this module is a thin
+    # scraping lives in {Tool::Scraper}; this module is a thin
     # wrapper that picks the scraper, applies a character cap so the LLM
     # doesn't drown in long-form content, and exposes the result to the
     # agent loop in OpenAI tool-call shape.
@@ -37,7 +37,7 @@ module Pikuri
         CACHE
       end
 
-      # Fetch +url+ via {Tool::Scraper::Simple} and truncate the rendered
+      # Fetch +url+ via {Tool::Scraper} and truncate the rendered
       # Markdown to +max_chars+ characters.
       #
       # The full extracted Markdown is cached on disk via {.cache}, keyed
@@ -65,7 +65,7 @@ module Pikuri
       #   truncated, or +"Error: ..."+ on a recoverable fetch failure
       def self.visit(url, max_chars: DEFAULT_MAX_CHARS)
         max_chars = max_chars.clamp(1, MAX_MAX_CHARS)
-        markdown = cache.fetch(url) { Scraper::Simple.visit(url) }
+        markdown = cache.fetch(url) { Scraper.visit(url) }
         truncate(markdown, max_chars)
       rescue Scraper::FetchError => e
         "Error: #{e.message}"
@@ -95,10 +95,10 @@ module Pikuri
     WEB_SCRAPE = new(
       name: 'web_scrape',
       description: <<~DESC,
-        Scrapes the rendered webpage, PDF, or text file at the given URL and returns its main content as Markdown.
+        Scrapes the rendered webpage or text file at the given URL and returns its main content as Markdown.
 
         Usage:
-        - Use for HTML pages or PDFs where you want readable content — readability extraction strips nav, sidebars, and boilerplate.
+        - Use for HTML pages where you want readable content — readability extraction strips nav, sidebars, and boilerplate.
         - For raw textual payloads (JSON, CSV, robots.txt, source files), use fetch instead — it returns bytes verbatim, while web_scrape would corrupt them with a Markdown pass.
         - A Single Page App may return very little or no content. Do NOT retry with a larger max_chars; try a different URL instead.
       DESC

data/lib/pikuri/version.rb

@@ -6,5 +6,5 @@ module Pikuri
   # additions to the public surface (+Pikuri::Tool+ / +Pikuri::Agent+ /
   # listeners / bundled tools), major for breaking changes to that
   # surface or to the +bin/pikuri-*+ CLIs.
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/lib/pikuri-core.rb

@@ -169,7 +169,6 @@ module Pikuri
   Loader.ignore(File.expand_path('pikuri/version.rb', __dir__))
   Loader.inflector.inflect(
     'html'       => 'HTML',
-    'pdf'        => 'PDF',
     'duckduckgo' => 'DuckDuckGo'
   )
   Loader.setup