@amrhas82/agentic-kit 1.7.0 → 1.7.5

package/packages/droid/commands/pdf/pdf.md

@@ -1,194 +0,0 @@
----
-description: Comprehensive PDF processing toolkit - extract text/tables, create PDFs, merge/split, handle forms
-argument-hint: <operation> <input-file>
----
-
-**Available Operations:**
-- `extract` - Extract text from PDF
-- `merge` - Merge multiple PDFs
-- `split` - Split PDF into individual pages
-- `form-check` - Check if PDF has fillable fields
-- `form-extract` - Extract form field information
-- `form-fill` - Fill PDF form fields
-- `convert-images` - Convert PDF pages to images
-- `create` - Create new PDF from text
-
-## Basic Operations
-
-### Extract Text
-```python
-from pypdf import PdfReader
-
-reader = PdfReader("document.pdf")
-text = ""
-for page in reader.pages:
-    text += page.extract_text()
-print(f"Extracted {len(text)} characters")
-```
-
-### Merge PDFs
-```python
-from pypdf import PdfWriter, PdfReader
-
-writer = PdfWriter()
-for pdf_file in ["doc1.pdf", "doc2.pdf"]:
-    reader = PdfReader(pdf_file)
-    for page in reader.pages:
-        writer.add_page(page)
-
-with open("merged.pdf", "wb") as output:
-    writer.write(output)
-```
-
-### Split PDF
-```python
-reader = PdfReader("input.pdf")
-for i, page in enumerate(reader.pages):
-    writer = PdfWriter()
-    writer.add_page(page)
-    with open(f"page_{i+1}.pdf", "wb") as output:
-        writer.write(output)
-```
-
-## Form Operations
-
-### Check Fillable Fields
-**CRITICAL:** First check if PDF has fillable form fields:
-```bash
-python scripts/check_fillable_fields.py <file.pdf>
-```
-
-### Extract Form Information
-If PDF has fillable fields, extract field data:
-```bash
-python scripts/extract_form_field_info.py <input.pdf> <field_info.json>
-```
-
-**Field Information Format:**
-```json
-[
-  {
-    "field_id": "unique-id",
-    "page": 1,
-    "rect": [left, bottom, right, top],
-    "type": "text|checkbox|radio_group|choice"
-  }
-]
-```
-
-### Fill Forms
-Use the extracted field information to programmatically fill the form:
-```python
-from pypdf import PdfReader, PdfWriter
-
-reader = PdfReader("form.pdf")
-writer = PdfWriter()
-
-# Copy all pages
-for page in reader.pages:
-    writer.add_page(page)
-
-# Update form fields
-field_data = {
-    "field_name": "value",
-    "checkbox_field": "Yes",
-    "dropdown": "Option 1"
-}
-
-writer.update_page_form_field_values(writer.pages[0], field_data)
-
-with open("filled_form.pdf", "wb") as output:
-    writer.write(output)
-```
-
-## Image Conversion
-
-### Convert to Images
-```python
-from pypdfium2 import PdfDocument
-from PIL import Image
-
-pdf = PdfDocument("document.pdf")
-for i, page in enumerate(pdf):
-    bitmap = page.render(scale=2.0)  # High resolution
-    img = bitmap.to_pil()
-    img.save(f"page_{i+1}.png")
-```
-
-## Advanced Features
-
-### PDFium2 for Fast Processing
-```python
-import pypdfium2 as pdfium
-
-pdf = pdfium.PdfDocument("document.pdf")
-for i, page in enumerate(pdf):
-    text = page.get_text()
-    bitmap = page.render(scale=1.5)
-    img = bitmap.to_pil()
-    img.save(f"page_{i+1}.jpg", quality=90)
-```
-
-### JavaScript with pdf-lib
-```javascript
-import { PDFDocument } from 'pdf-lib';
-import fs from 'fs';
-
-async function manipulatePDF() {
-    const pdfDoc = await PDFDocument.load(fs.readFileSync('input.pdf'));
-    const pageCount = pdfDoc.getPageCount();
-    
-    const newPage = pdfDoc.addPage([600, 400]);
-    newPage.drawText('Added content', { x: 100, y: 300, size: 16 });
-    
-    fs.writeFileSync('modified.pdf', await pdfDoc.save());
-}
-```
-
-## Common Patterns
-
-### Bounding Box Extraction
-For non-fillable forms, extract coordinates:
-```python
-# Scripts available for analyzing PDF structure
-# check_bounding_boxes.py - Visual analysis tool
-# create_validation_image.py - Generate preview with field locations
-```
-
-### Table Extraction
-```python
-# Use pdfplumber for structured table extraction
-import pdfplumber
-
-with pdfplumber.open("document.pdf") as pdf:
-    for page in pdf.pages:
-        tables = page.extract_tables()
-        for table in tables:
-            print(table)
-```
-
-### Error Handling
-```python
-try:
-    reader = PdfReader("file.pdf")
-    text = page.extract_text()
-except Exception as e:
-    print(f"Error processing PDF: {e}")
-```
-
-## Usage Examples
-
-**Extract text from report:**
-`/pdf extract monthly-report.pdf`
-
-**Merge multiple invoices:**
-`/pdf merge invoice1.pdf invoice2.pdf invoice3.pdf`
-
-**Check form fields:**
-`/pdf form-check application-form.pdf`
-
-**Convert to images for analysis:**
-`/pdf convert-images document.pdf`
-
-**Create simple PDF:**
-`/pdf create "Hello World" output.pdf`

package/packages/droid/commands/pdf/scripts/check_bounding_boxes.py

@@ -1,70 +0,0 @@
-from dataclasses import dataclass
-import json
-import sys
-
-
-# Script to check that the `fields.json` file that Claude creates when analyzing PDFs
-# does not have overlapping bounding boxes. See forms.md.
-
-
-@dataclass
-class RectAndField:
-    rect: list[float]
-    rect_type: str
-    field: dict
-
-
-# Returns a list of messages that are printed to stdout for Claude to read.
-def get_bounding_box_messages(fields_json_stream) -> list[str]:
-    messages = []
-    fields = json.load(fields_json_stream)
-    messages.append(f"Read {len(fields['form_fields'])} fields")
-
-    def rects_intersect(r1, r2):
-        disjoint_horizontal = r1[0] >= r2[2] or r1[2] <= r2[0]
-        disjoint_vertical = r1[1] >= r2[3] or r1[3] <= r2[1]
-        return not (disjoint_horizontal or disjoint_vertical)
-
-    rects_and_fields = []
-    for f in fields["form_fields"]:
-        rects_and_fields.append(RectAndField(f["label_bounding_box"], "label", f))
-        rects_and_fields.append(RectAndField(f["entry_bounding_box"], "entry", f))
-
-    has_error = False
-    for i, ri in enumerate(rects_and_fields):
-        # This is O(N^2); we can optimize if it becomes a problem.
-        for j in range(i + 1, len(rects_and_fields)):
-            rj = rects_and_fields[j]
-            if ri.field["page_number"] == rj.field["page_number"] and rects_intersect(ri.rect, rj.rect):
-                has_error = True
-                if ri.field is rj.field:
-                    messages.append(f"FAILURE: intersection between label and entry bounding boxes for `{ri.field['description']}` ({ri.rect}, {rj.rect})")
-                else:
-                    messages.append(f"FAILURE: intersection between {ri.rect_type} bounding box for `{ri.field['description']}` ({ri.rect}) and {rj.rect_type} bounding box for `{rj.field['description']}` ({rj.rect})")
-                if len(messages) >= 20:
-                    messages.append("Aborting further checks; fix bounding boxes and try again")
-                    return messages
-        if ri.rect_type == "entry":
-            if "entry_text" in ri.field:
-                font_size = ri.field["entry_text"].get("font_size", 14)
-                entry_height = ri.rect[3] - ri.rect[1]
-                if entry_height < font_size:
-                    has_error = True
-                    messages.append(f"FAILURE: entry bounding box height ({entry_height}) for `{ri.field['description']}` is too short for the text content (font size: {font_size}). Increase the box height or decrease the font size.")
-                    if len(messages) >= 20:
-                        messages.append("Aborting further checks; fix bounding boxes and try again")
-                        return messages
-
-    if not has_error:
-        messages.append("SUCCESS: All bounding boxes are valid")
-    return messages
-
-if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: check_bounding_boxes.py [fields.json]")
-        sys.exit(1)
-    # Input file should be in the `fields.json` format described in forms.md.
-    with open(sys.argv[1]) as f:
-        messages = get_bounding_box_messages(f)
-    for msg in messages:
-        print(msg)

package/packages/droid/commands/pdf/scripts/check_bounding_boxes_test.py

@@ -1,226 +0,0 @@
-import unittest
-import json
-import io
-from check_bounding_boxes import get_bounding_box_messages
-
-
-# Currently this is not run automatically in CI; it's just for documentation and manual checking.
-class TestGetBoundingBoxMessages(unittest.TestCase):
-    
-    def create_json_stream(self, data):
-        """Helper to create a JSON stream from data"""
-        return io.StringIO(json.dumps(data))
-    
-    def test_no_intersections(self):
-        """Test case with no bounding box intersections"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [60, 10, 150, 30]
-                },
-                {
-                    "description": "Email",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 40, 50, 60],
-                    "entry_bounding_box": [60, 40, 150, 60]
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("SUCCESS" in msg for msg in messages))
-        self.assertFalse(any("FAILURE" in msg for msg in messages))
-    
-    def test_label_entry_intersection_same_field(self):
-        """Test intersection between label and entry of the same field"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 60, 30],
-                    "entry_bounding_box": [50, 10, 150, 30]  # Overlaps with label
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("FAILURE" in msg and "intersection" in msg for msg in messages))
-        self.assertFalse(any("SUCCESS" in msg for msg in messages))
-    
-    def test_intersection_between_different_fields(self):
-        """Test intersection between bounding boxes of different fields"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [60, 10, 150, 30]
-                },
-                {
-                    "description": "Email",
-                    "page_number": 1,
-                    "label_bounding_box": [40, 20, 80, 40],  # Overlaps with Name's boxes
-                    "entry_bounding_box": [160, 10, 250, 30]
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("FAILURE" in msg and "intersection" in msg for msg in messages))
-        self.assertFalse(any("SUCCESS" in msg for msg in messages))
-    
-    def test_different_pages_no_intersection(self):
-        """Test that boxes on different pages don't count as intersecting"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [60, 10, 150, 30]
-                },
-                {
-                    "description": "Email",
-                    "page_number": 2,
-                    "label_bounding_box": [10, 10, 50, 30],  # Same coordinates but different page
-                    "entry_bounding_box": [60, 10, 150, 30]
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("SUCCESS" in msg for msg in messages))
-        self.assertFalse(any("FAILURE" in msg for msg in messages))
-    
-    def test_entry_height_too_small(self):
-        """Test that entry box height is checked against font size"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [60, 10, 150, 20],  # Height is 10
-                    "entry_text": {
-                        "font_size": 14  # Font size larger than height
-                    }
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("FAILURE" in msg and "height" in msg for msg in messages))
-        self.assertFalse(any("SUCCESS" in msg for msg in messages))
-    
-    def test_entry_height_adequate(self):
-        """Test that adequate entry box height passes"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [60, 10, 150, 30],  # Height is 20
-                    "entry_text": {
-                        "font_size": 14  # Font size smaller than height
-                    }
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("SUCCESS" in msg for msg in messages))
-        self.assertFalse(any("FAILURE" in msg for msg in messages))
-    
-    def test_default_font_size(self):
-        """Test that default font size is used when not specified"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [60, 10, 150, 20],  # Height is 10
-                    "entry_text": {}  # No font_size specified, should use default 14
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("FAILURE" in msg and "height" in msg for msg in messages))
-        self.assertFalse(any("SUCCESS" in msg for msg in messages))
-    
-    def test_no_entry_text(self):
-        """Test that missing entry_text doesn't cause height check"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [60, 10, 150, 20]  # Small height but no entry_text
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("SUCCESS" in msg for msg in messages))
-        self.assertFalse(any("FAILURE" in msg for msg in messages))
-    
-    def test_multiple_errors_limit(self):
-        """Test that error messages are limited to prevent excessive output"""
-        fields = []
-        # Create many overlapping fields
-        for i in range(25):
-            fields.append({
-                "description": f"Field{i}",
-                "page_number": 1,
-                "label_bounding_box": [10, 10, 50, 30],  # All overlap
-                "entry_bounding_box": [20, 15, 60, 35]   # All overlap
-            })
-        
-        data = {"form_fields": fields}
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        # Should abort after ~20 messages
-        self.assertTrue(any("Aborting" in msg for msg in messages))
-        # Should have some FAILURE messages but not hundreds
-        failure_count = sum(1 for msg in messages if "FAILURE" in msg)
-        self.assertGreater(failure_count, 0)
-        self.assertLess(len(messages), 30)  # Should be limited
-    
-    def test_edge_touching_boxes(self):
-        """Test that boxes touching at edges don't count as intersecting"""
-        data = {
-            "form_fields": [
-                {
-                    "description": "Name",
-                    "page_number": 1,
-                    "label_bounding_box": [10, 10, 50, 30],
-                    "entry_bounding_box": [50, 10, 150, 30]  # Touches at x=50
-                }
-            ]
-        }
-        
-        stream = self.create_json_stream(data)
-        messages = get_bounding_box_messages(stream)
-        self.assertTrue(any("SUCCESS" in msg for msg in messages))
-        self.assertFalse(any("FAILURE" in msg for msg in messages))
-    
-
-if __name__ == '__main__':
-    unittest.main()

package/packages/droid/commands/pdf/scripts/check_fillable_fields.py

@@ -1,12 +0,0 @@
-import sys
-from pypdf import PdfReader
-
-
-# Script for Claude to run to determine whether a PDF has fillable form fields. See forms.md.
-
-
-reader = PdfReader(sys.argv[1])
-if (reader.get_fields()):
-    print("This PDF has fillable form fields")
-else:
-    print("This PDF does not have fillable form fields; you will need to visually determine where to enter data")

package/packages/droid/commands/pdf/scripts/convert_pdf_to_images.py

@@ -1,35 +0,0 @@
-import os
-import sys
-
-from pdf2image import convert_from_path
-
-
-# Converts each page of a PDF to a PNG image.
-
-
-def convert(pdf_path, output_dir, max_dim=1000):
-    images = convert_from_path(pdf_path, dpi=200)
-
-    for i, image in enumerate(images):
-        # Scale image if needed to keep width/height under `max_dim`
-        width, height = image.size
-        if width > max_dim or height > max_dim:
-            scale_factor = min(max_dim / width, max_dim / height)
-            new_width = int(width * scale_factor)
-            new_height = int(height * scale_factor)
-            image = image.resize((new_width, new_height))
-        
-        image_path = os.path.join(output_dir, f"page_{i+1}.png")
-        image.save(image_path)
-        print(f"Saved page {i+1} as {image_path} (size: {image.size})")
-
-    print(f"Converted {len(images)} pages to PNG images")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 3:
-        print("Usage: convert_pdf_to_images.py [input pdf] [output directory]")
-        sys.exit(1)
-    pdf_path = sys.argv[1]
-    output_directory = sys.argv[2]
-    convert(pdf_path, output_directory)

package/packages/droid/commands/pdf/scripts/create_validation_image.py

@@ -1,41 +0,0 @@
-import json
-import sys
-
-from PIL import Image, ImageDraw
-
-
-# Creates "validation" images with rectangles for the bounding box information that
-# Claude creates when determining where to add text annotations in PDFs. See forms.md.
-
-
-def create_validation_image(page_number, fields_json_path, input_path, output_path):
-    # Input file should be in the `fields.json` format described in forms.md.
-    with open(fields_json_path, 'r') as f:
-        data = json.load(f)
-
-        img = Image.open(input_path)
-        draw = ImageDraw.Draw(img)
-        num_boxes = 0
-        
-        for field in data["form_fields"]:
-            if field["page_number"] == page_number:
-                entry_box = field['entry_bounding_box']
-                label_box = field['label_bounding_box']
-                # Draw red rectangle over entry bounding box and blue rectangle over the label.
-                draw.rectangle(entry_box, outline='red', width=2)
-                draw.rectangle(label_box, outline='blue', width=2)
-                num_boxes += 2
-        
-        img.save(output_path)
-        print(f"Created validation image at {output_path} with {num_boxes} bounding boxes")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 5:
-        print("Usage: create_validation_image.py [page number] [fields.json file] [input image path] [output image path]")
-        sys.exit(1)
-    page_number = int(sys.argv[1])
-    fields_json_path = sys.argv[2]
-    input_image_path = sys.argv[3]
-    output_image_path = sys.argv[4]
-    create_validation_image(page_number, fields_json_path, input_image_path, output_image_path)