mathpix 0.1.0 → 0.1.2

data/lib/mathpix/mcp/tools/batch_convert_tool.rb

@@ -12,33 +12,33 @@ module Mathpix
       #
       # The geodesic path: official SDK + batch iteration
       class BatchConvertTool < BaseTool
-        description "Convert multiple images in batch using Mathpix OCR"
+        description 'Convert multiple images in batch using Mathpix OCR'
 
         input_schema(
           properties: {
             image_paths: {
-              type: "array",
-              items: { type: "string" },
-              description: "Array of image paths or URLs to process"
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Array of image paths or URLs to process'
             },
             formats: {
-              type: "array",
-              items: { type: "string" },
-              description: "Output formats for all images: latex, text, mathml, asciimath (default: latex_styled, text)"
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Output formats for all images: latex, text, mathml, asciimath (default: latex_styled, text)'
             },
             parallel: {
-              type: "boolean",
-              description: "Process images in parallel (default: false)"
+              type: 'boolean',
+              description: 'Process images in parallel (default: false)'
             },
             max_parallel: {
-              type: "number",
-              description: "Maximum number of parallel requests (default: 3)"
+              type: 'number',
+              description: 'Maximum number of parallel requests (default: 3)'
             }
           },
-          required: ["image_paths"]
+          required: ['image_paths']
         )
 
-        def self.call(image_paths:, formats: nil, parallel: false, max_parallel: 3, server_context:)
+        def self.call(image_paths:, server_context:, formats: nil, parallel: false, max_parallel: 3)
           safe_execute do
             client = mathpix_client(server_context)
 
@@ -51,13 +51,11 @@ module Mathpix
             end
 
             # Process images
-            results = if parallel
+            if parallel
               # TODO: Implement parallel processing (requires threading)
               # For now, process sequentially
-              process_batch_sequential(client, normalized_paths, output_formats)
-            else
-              process_batch_sequential(client, normalized_paths, output_formats)
             end
+            results = process_batch_sequential(client, normalized_paths, output_formats)
 
             # Format response
             response_data = {
@@ -76,28 +74,24 @@ module Mathpix
           end
         end
 
-        private
-
         def self.process_batch_sequential(client, paths, formats)
           paths.map.with_index do |path, index|
-            begin
-              result = client.snap(path, formats: formats)
-              {
-                index: index,
-                image_path: path,
-                success: true,
-                latex: result.latex,
-                text: result.text,
-                confidence: result.confidence
-              }
-            rescue Mathpix::Error => e
-              {
-                index: index,
-                image_path: path,
-                success: false,
-                error: e.message
-              }
-            end
+            result = client.snap(path, formats: formats)
+            {
+              index: index,
+              image_path: path,
+              success: true,
+              latex: result.latex,
+              text: result.text,
+              confidence: result.confidence
+            }
+          rescue Mathpix::Error => e
+            {
+              index: index,
+              image_path: path,
+              success: false,
+              error: e.message
+            }
           end
         end
       end

data/lib/mathpix/mcp/tools/check_document_status_tool.rb

@@ -12,16 +12,16 @@ module Mathpix
       #
       # The geodesic path: official SDK + status polling
       class CheckDocumentStatusTool < BaseTool
-        description "Check the status of a document conversion (PDF, DOCX, PPTX)"
+        description 'Check the status of a document conversion (PDF, DOCX, PPTX)'
 
         input_schema(
           properties: {
             conversion_id: {
-              type: "string",
-              description: "Document conversion ID returned from convert_document"
+              type: 'string',
+              description: 'Document conversion ID returned from convert_document'
             }
           },
-          required: ["conversion_id"]
+          required: ['conversion_id']
         )
 
         def self.call(conversion_id:, server_context:)
@@ -52,7 +52,7 @@ module Mathpix
             end
 
             # Add error info if failed
-            if status_data['status'] == 'error' || status_data['status'] == 'failed'
+            if %w[error failed].include?(status_data['status'])
               response_data[:error] = status_data['error']
               response_data[:error_info] = status_data['error_info']
             end

data/lib/mathpix/mcp/tools/convert_document_tool.rb

@@ -12,36 +12,37 @@ module Mathpix
       #
       # The geodesic path: official SDK + Document class delegation
       class ConvertDocumentTool < BaseTool
-        description "Convert document (PDF, DOCX, PPTX) to Markdown, LaTeX, HTML, or other formats using Mathpix OCR"
+        description 'Convert document (PDF, DOCX, PPTX) to Markdown, LaTeX, HTML, or other formats using Mathpix OCR'
 
         input_schema(
           properties: {
             document_path: {
-              type: "string",
-              description: "Path to document file or URL (PDF, DOCX, or PPTX)"
+              type: 'string',
+              description: 'Path to document file or URL (PDF, DOCX, or PPTX)'
             },
             formats: {
-              type: "array",
-              items: { type: "string" },
-              description: "Output formats: markdown, latex, html, docx (default: markdown)"
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Output formats: markdown, latex, html, docx (default: markdown)'
             },
             include_tables: {
-              type: "boolean",
-              description: "Include table extraction as HTML"
+              type: 'boolean',
+              description: 'Include table extraction as HTML'
             },
             max_wait: {
-              type: "number",
-              description: "Maximum wait time in seconds for conversion (default: 600)"
+              type: 'number',
+              description: 'Maximum wait time in seconds for conversion (default: 600)'
             },
             poll_interval: {
-              type: "number",
-              description: "Polling interval in seconds (default: 3.0)"
+              type: 'number',
+              description: 'Polling interval in seconds (default: 3.0)'
             }
           },
-          required: ["document_path"]
+          required: ['document_path']
         )
 
-        def self.call(document_path:, formats: nil, include_tables: false, max_wait: 600, poll_interval: 3.0, server_context:)
+        def self.call(document_path:, server_context:, formats: nil, include_tables: false, max_wait: 600,
+                      poll_interval: 3.0)
           safe_execute do
             client = mathpix_client(server_context)
 

data/lib/mathpix/mcp/tools/convert_image_tool.rb

@@ -12,36 +12,37 @@ module Mathpix
       #
       # The geodesic path: official SDK + core gem delegation
       class ConvertImageTool < BaseTool
-        description "Convert image (PNG, JPG, etc.) to LaTeX, text, or other formats using Mathpix OCR"
+        description 'Convert image (PNG, JPG, etc.) to LaTeX, text, or other formats using Mathpix OCR'
 
         input_schema(
           properties: {
             image_path: {
-              type: "string",
-              description: "Path to image file or URL (http:// or https://)"
+              type: 'string',
+              description: 'Path to image file or URL (http:// or https://)'
             },
             formats: {
-              type: "array",
-              items: { type: "string" },
-              description: "Output formats: latex, text, mathml, asciimath, latex_styled, text_display, data, html (default: latex_styled, text)"
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Output formats: latex, text, mathml, asciimath, latex_styled, text_display, data, html (default: latex_styled, text)'
             },
             include_line_data: {
-              type: "boolean",
-              description: "Include line-level bounding boxes in response"
+              type: 'boolean',
+              description: 'Include line-level bounding boxes in response'
             },
             include_word_data: {
-              type: "boolean",
-              description: "Include word-level bounding boxes in response"
+              type: 'boolean',
+              description: 'Include word-level bounding boxes in response'
             },
             confidence_threshold: {
-              type: "number",
-              description: "Minimum confidence threshold (0.0-1.0)"
+              type: 'number',
+              description: 'Minimum confidence threshold (0.0-1.0)'
             }
           },
-          required: ["image_path"]
+          required: ['image_path']
         )
 
-        def self.call(image_path:, formats: nil, include_line_data: false, include_word_data: false, confidence_threshold: nil, server_context:)
+        def self.call(image_path:, server_context:, formats: nil, include_line_data: false, include_word_data: false,
+                      confidence_threshold: nil)
           safe_execute do
             client = mathpix_client(server_context)
 

data/lib/mathpix/mcp/tools/convert_strokes_tool.rb

@@ -12,32 +12,32 @@ module Mathpix
       #
       # The geodesic path: official SDK + stroke recognition
       class ConvertStrokesTool < BaseTool
-        description "Convert handwritten strokes to LaTeX, text, or other formats using Mathpix OCR"
+        description 'Convert handwritten strokes to LaTeX, text, or other formats using Mathpix OCR'
 
         input_schema(
           properties: {
             strokes: {
-              type: "array",
-              description: "Array of stroke arrays, where each stroke is an array of [x, y] coordinates"
+              type: 'array',
+              description: 'Array of stroke arrays, where each stroke is an array of [x, y] coordinates'
             },
             formats: {
-              type: "array",
-              items: { type: "string" },
-              description: "Output formats: latex, text, mathml, asciimath (default: latex_styled, text)"
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Output formats: latex, text, mathml, asciimath (default: latex_styled, text)'
             },
             width: {
-              type: "number",
-              description: "Canvas width for stroke normalization"
+              type: 'number',
+              description: 'Canvas width for stroke normalization'
             },
             height: {
-              type: "number",
-              description: "Canvas height for stroke normalization"
+              type: 'number',
+              description: 'Canvas height for stroke normalization'
             }
           },
-          required: ["strokes"]
+          required: ['strokes']
         )
 
-        def self.call(strokes:, formats: nil, width: nil, height: nil, server_context:)
+        def self.call(strokes:, server_context:, formats: nil, width: nil, height: nil)
           safe_execute do
             client = mathpix_client(server_context)
 
@@ -57,7 +57,7 @@ module Mathpix
             # Format response
             response_data = {
               success: true,
-              input_type: "strokes",
+              input_type: 'strokes',
               stroke_count: strokes.length,
               formats: output_formats,
               results: {

data/lib/mathpix/mcp/tools/get_account_info_tool.rb

@@ -12,7 +12,7 @@ module Mathpix
       #
       # The geodesic path: official SDK + account management
       class GetAccountInfoTool < BaseTool
-        description "Get Mathpix account information, plan details, and limits"
+        description 'Get Mathpix account information, plan details, and limits'
 
         input_schema(
           properties: {},

data/lib/mathpix/mcp/tools/get_usage_tool.rb

@@ -12,19 +12,19 @@ module Mathpix
       #
       # The geodesic path: official SDK + usage tracking
       class GetUsageTool < BaseTool
-        description "Get Mathpix API usage statistics and remaining credits"
+        description 'Get Mathpix API usage statistics and remaining credits'
 
         input_schema(
           properties: {
             detailed: {
-              type: "boolean",
-              description: "Include detailed breakdown by operation type (default: false)"
+              type: 'boolean',
+              description: 'Include detailed breakdown by operation type (default: false)'
             }
           },
           required: []
         )
 
-        def self.call(detailed: false, server_context:)
+        def self.call(server_context:, detailed: false)
           safe_execute do
             client = mathpix_client(server_context)
 
@@ -42,9 +42,7 @@ module Mathpix
                 }
               }
 
-              if detailed && usage_data['breakdown']
-                response_data[:breakdown] = usage_data['breakdown']
-              end
+              response_data[:breakdown] = usage_data['breakdown'] if detailed && usage_data['breakdown']
 
               json_response(response_data)
             rescue Mathpix::APIError => e

data/lib/mathpix/mcp/tools/list_formats_tool.rb

@@ -12,53 +12,53 @@ module Mathpix
       #
       # The geodesic path: official SDK + format catalog
       class ListFormatsTool < BaseTool
-        description "List all available output formats for Mathpix OCR operations"
+        description 'List all available output formats for Mathpix OCR operations'
 
         input_schema(
           properties: {
             category: {
-              type: "string",
-              description: "Filter by category: image, document, or all (default: all)",
-              enum: ["image", "document", "all"]
+              type: 'string',
+              description: 'Filter by category: image, document, or all (default: all)',
+              enum: %w[image document all]
             }
           },
           required: []
         )
 
-        def self.call(category: "all", server_context:)
+        def self.call(server_context:, category: 'all')
           safe_execute do
             # Static format definitions
             image_formats = [
-              { name: "latex_styled", description: "LaTeX with styling", type: "image" },
-              { name: "text", description: "Plain text", type: "image" },
-              { name: "latex_list", description: "Array of LaTeX expressions", type: "image" },
-              { name: "mathml", description: "MathML markup", type: "image" },
-              { name: "asciimath", description: "AsciiMath notation", type: "image" },
-              { name: "text_display", description: "Display-style text", type: "image" },
-              { name: "latex_simplified", description: "Simplified LaTeX", type: "image" },
-              { name: "data", description: "Full response data with metadata", type: "image" },
-              { name: "html", description: "HTML markup", type: "image" }
+              { name: 'latex_styled', description: 'LaTeX with styling', type: 'image' },
+              { name: 'text', description: 'Plain text', type: 'image' },
+              { name: 'latex_list', description: 'Array of LaTeX expressions', type: 'image' },
+              { name: 'mathml', description: 'MathML markup', type: 'image' },
+              { name: 'asciimath', description: 'AsciiMath notation', type: 'image' },
+              { name: 'text_display', description: 'Display-style text', type: 'image' },
+              { name: 'latex_simplified', description: 'Simplified LaTeX', type: 'image' },
+              { name: 'data', description: 'Full response data with metadata', type: 'image' },
+              { name: 'html', description: 'HTML markup', type: 'image' }
             ]
 
             document_formats = [
-              { name: "markdown", description: "Markdown format", type: "document" },
-              { name: "latex", description: "LaTeX document", type: "document" },
-              { name: "html", description: "HTML document", type: "document" },
-              { name: "docx", description: "Microsoft Word document", type: "document" },
-              { name: "tex.zip", description: "LaTeX with figures (zipped)", type: "document" }
+              { name: 'markdown', description: 'Markdown format', type: 'document' },
+              { name: 'latex', description: 'LaTeX document', type: 'document' },
+              { name: 'html', description: 'HTML document', type: 'document' },
+              { name: 'docx', description: 'Microsoft Word document', type: 'document' },
+              { name: 'tex.zip', description: 'LaTeX with figures (zipped)', type: 'document' }
             ]
 
             # Filter by category
             formats = case category
-            when "image"
-              image_formats
-            when "document"
-              document_formats
-            when "all"
-              image_formats + document_formats
-            else
-              image_formats + document_formats
-            end
+                      when 'image'
+                        image_formats
+                      when 'document'
+                        document_formats
+                      when 'all'
+                        image_formats + document_formats
+                      else
+                        image_formats + document_formats
+                      end
 
             # Format response
             response_data = {
@@ -67,8 +67,8 @@ module Mathpix
               count: formats.length,
               formats: formats,
               usage: {
-                image_capture: "Use with snap() or ConvertImageTool",
-                document_conversion: "Use with document() or ConvertDocumentTool"
+                image_capture: 'Use with snap() or ConvertImageTool',
+                document_conversion: 'Use with document() or ConvertDocumentTool'
               }
             }
 

data/lib/mathpix/mcp/tools/search_results_tool.rb

@@ -12,31 +12,31 @@ module Mathpix
       #
       # The geodesic path: official SDK + search filtering
       class SearchResultsTool < BaseTool
-        description "Search recent Mathpix capture results with optional text filtering"
+        description 'Search recent Mathpix capture results with optional text filtering'
 
         input_schema(
           properties: {
             query: {
-              type: "string",
-              description: "Search query to filter results by LaTeX or text content"
+              type: 'string',
+              description: 'Search query to filter results by LaTeX or text content'
             },
             limit: {
-              type: "number",
-              description: "Maximum number of results to return (default: 10, max: 100)"
+              type: 'number',
+              description: 'Maximum number of results to return (default: 10, max: 100)'
             },
             offset: {
-              type: "number",
-              description: "Offset for pagination (default: 0)"
+              type: 'number',
+              description: 'Offset for pagination (default: 0)'
             },
             include_content: {
-              type: "boolean",
-              description: "Include full LaTeX/text content in results (default: false)"
+              type: 'boolean',
+              description: 'Include full LaTeX/text content in results (default: false)'
             }
           },
           required: []
         )
 
-        def self.call(query: nil, limit: 10, offset: 0, include_content: false, server_context:)
+        def self.call(server_context:, query: nil, limit: 10, offset: 0, include_content: false)
           safe_execute do
             client = mathpix_client(server_context)
 
@@ -53,8 +53,8 @@ module Mathpix
             if query && !query.empty?
               query_lower = query.downcase
               results = results.select do |result|
-                (result.latex&.downcase&.include?(query_lower)) ||
-                (result.text&.downcase&.include?(query_lower))
+                result.latex&.downcase&.include?(query_lower) ||
+                  result.text&.downcase&.include?(query_lower)
               end
             end
 
@@ -98,11 +98,10 @@ module Mathpix
           end
         end
 
-        private
-
         def self.truncate(text, max_length)
           return nil unless text
           return text if text.length <= max_length
+
           "#{text[0...max_length]}..."
         end
       end