@heylemon/lemonade 0.0.4 → 0.0.6

package/skills/pptx/scripts/office/validators/redlining.py

@@ -9,7 +9,6 @@ from pathlib import Path
 
 
 class RedliningValidator:
-    """Validator for tracked changes in Word documents."""
 
     def __init__(self, unpacked_dir, original_docx, verbose=False, author="Claude"):
         self.unpacked_dir = Path(unpacked_dir)
@@ -21,29 +20,23 @@ class RedliningValidator:
         }
 
     def repair(self) -> int:
-        """No auto-repairs for redlining validation. Returns 0."""
         return 0
 
     def validate(self):
-        """Main validation method that returns True if valid, False otherwise."""
-        # Verify unpacked directory exists and has correct structure
         modified_file = self.unpacked_dir / "word" / "document.xml"
         if not modified_file.exists():
             print(f"FAILED - Modified document.xml not found at {modified_file}")
             return False
 
-        # First, check if there are any tracked changes by the author to validate
         try:
             import xml.etree.ElementTree as ET
 
             tree = ET.parse(modified_file)
             root = tree.getroot()
 
-            # Check for w:del or w:ins tags by the specified author
             del_elements = root.findall(".//w:del", self.namespaces)
             ins_elements = root.findall(".//w:ins", self.namespaces)
 
-            # Filter to only include changes by the specified author
             author_del_elements = [
                 elem
                 for elem in del_elements
@@ -55,21 +48,17 @@ class RedliningValidator:
                 if elem.get(f"{{{self.namespaces['w']}}}author") == self.author
             ]
 
-            # Redlining validation is only needed if tracked changes by the author have been used.
             if not author_del_elements and not author_ins_elements:
                 if self.verbose:
                     print(f"PASSED - No tracked changes by {self.author} found.")
                 return True
 
         except Exception:
-            # If we can't parse the XML, continue with full validation
             pass
 
-        # Create temporary directory for unpacking original docx
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_path = Path(temp_dir)
 
-            # Unpack original docx
             try:
                 with zipfile.ZipFile(self.original_docx, "r") as zip_ref:
                     zip_ref.extractall(temp_path)
@@ -84,7 +73,6 @@ class RedliningValidator:
                 )
                 return False
 
-            # Parse both XML files using xml.etree.ElementTree for redlining validation
             try:
                 import xml.etree.ElementTree as ET
 
@@ -96,16 +84,13 @@ class RedliningValidator:
                 print(f"FAILED - Error parsing XML files: {e}")
                 return False
 
-            # Remove the author's tracked changes from both documents
             self._remove_author_tracked_changes(original_root)
             self._remove_author_tracked_changes(modified_root)
 
-            # Extract and compare text content
             modified_text = self._extract_text_content(modified_root)
             original_text = self._extract_text_content(original_root)
 
             if modified_text != original_text:
-                # Show detailed character-level differences for each paragraph
                 error_message = self._generate_detailed_diff(
                     original_text, modified_text
                 )
@@ -117,7 +102,6 @@ class RedliningValidator:
             return True
 
     def _generate_detailed_diff(self, original_text, modified_text):
-        """Generate detailed word-level differences using git word diff."""
         error_parts = [
             f"FAILED - Document text doesn't match after removing {self.author}'s tracked changes",
             "",
@@ -132,7 +116,6 @@ class RedliningValidator:
             "",
         ]
 
-        # Show git word diff
         git_diff = self._get_git_word_diff(original_text, modified_text)
         if git_diff:
             error_parts.extend(["Differences:", "============", git_diff])
@@ -142,26 +125,23 @@ class RedliningValidator:
         return "\n".join(error_parts)
 
     def _get_git_word_diff(self, original_text, modified_text):
-        """Generate word diff using git with character-level precision."""
         try:
             with tempfile.TemporaryDirectory() as temp_dir:
                 temp_path = Path(temp_dir)
 
-                # Create two files
                 original_file = temp_path / "original.txt"
                 modified_file = temp_path / "modified.txt"
 
                 original_file.write_text(original_text, encoding="utf-8")
                 modified_file.write_text(modified_text, encoding="utf-8")
 
-                # Try character-level diff first for precise differences
                 result = subprocess.run(
                     [
                         "git",
                         "diff",
                         "--word-diff=plain",
-                        "--word-diff-regex=.",  # Character-by-character diff
-                        "-U0",  # Zero lines of context - show only changed lines
+                        "--word-diff-regex=.",  
+                        "-U0",  
                         "--no-index",
                         str(original_file),
                         str(modified_file),
@@ -171,9 +151,7 @@ class RedliningValidator:
                 )
 
                 if result.stdout.strip():
-                    # Clean up the output - remove git diff header lines
                     lines = result.stdout.split("\n")
-                    # Skip the header lines (diff --git, index, +++, ---, @@)
                     content_lines = []
                     in_content = False
                     for line in lines:
@@ -186,13 +164,12 @@ class RedliningValidator:
                     if content_lines:
                         return "\n".join(content_lines)
 
-                # Fallback to word-level diff if character-level is too verbose
                 result = subprocess.run(
                     [
                         "git",
                         "diff",
                         "--word-diff=plain",
-                        "-U0",  # Zero lines of context
+                        "-U0",  
                         "--no-index",
                         str(original_file),
                         str(modified_file),
@@ -214,18 +191,15 @@ class RedliningValidator:
                     return "\n".join(content_lines)
 
         except (subprocess.CalledProcessError, FileNotFoundError, Exception):
-            # Git not available or other error, return None to use fallback
             pass
 
         return None
 
     def _remove_author_tracked_changes(self, root):
-        """Remove tracked changes authored by the specified author from the XML root."""
         ins_tag = f"{{{self.namespaces['w']}}}ins"
         del_tag = f"{{{self.namespaces['w']}}}del"
         author_attr = f"{{{self.namespaces['w']}}}author"
 
-        # Remove w:ins elements
         for parent in root.iter():
             to_remove = []
             for child in parent:
@@ -234,7 +208,6 @@ class RedliningValidator:
             for elem in to_remove:
                 parent.remove(elem)
 
-        # Unwrap content in w:del elements where author matches
         deltext_tag = f"{{{self.namespaces['w']}}}delText"
         t_tag = f"{{{self.namespaces['w']}}}t"
 
@@ -244,36 +217,26 @@ class RedliningValidator:
                 if child.tag == del_tag and child.get(author_attr) == self.author:
                     to_process.append((child, list(parent).index(child)))
 
-            # Process in reverse order to maintain indices
             for del_elem, del_index in reversed(to_process):
-                # Convert w:delText to w:t before moving
                 for elem in del_elem.iter():
                     if elem.tag == deltext_tag:
                         elem.tag = t_tag
 
-                # Move all children of w:del to its parent before removing w:del
                 for child in reversed(list(del_elem)):
                     parent.insert(del_index, child)
                 parent.remove(del_elem)
 
     def _extract_text_content(self, root):
-        """Extract text content from Word XML, preserving paragraph structure.
-
-        Empty paragraphs are skipped to avoid false positives when tracked
-        insertions add only structural elements without text content.
-        """
         p_tag = f"{{{self.namespaces['w']}}}p"
         t_tag = f"{{{self.namespaces['w']}}}t"
 
         paragraphs = []
         for p_elem in root.findall(f".//{p_tag}"):
-            # Get all text elements within this paragraph
             text_parts = []
             for t_elem in p_elem.findall(f".//{t_tag}"):
                 if t_elem.text:
                     text_parts.append(t_elem.text)
             paragraph_text = "".join(text_parts)
-            # Skip empty paragraphs - they don't affect content validation
             if paragraph_text:
                 paragraphs.append(paragraph_text)
 

package/skills/pptx/scripts/thumbnail.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """Create thumbnail grids from PowerPoint presentation slides.
 
 Creates a grid layout of slide thumbnails for quick visual analysis.
@@ -27,7 +26,6 @@ import defusedxml.minidom
 from office.soffice import get_soffice_env
 from PIL import Image, ImageDraw, ImageFont
 
-# Constants
 THUMBNAIL_WIDTH = 300
 CONVERSION_DPI = 100
 MAX_COLS = 6
@@ -71,7 +69,6 @@ def main():
     output_path = Path(f"{args.output_prefix}.jpg")
 
     try:
-        # Get slide info (filenames and hidden status) in presentation order
         slide_info = get_slide_info(input_path)
 
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -82,7 +79,6 @@ def main():
                 print("Error: No slides found", file=sys.stderr)
                 sys.exit(1)
 
-            # Build slide list with images (visible) or placeholders (hidden)
             slides = build_slide_list(slide_info, visible_images, temp_path)
 
             grid_files = create_grids(slides, cols, THUMBNAIL_WIDTH, output_path)
@@ -97,12 +93,7 @@ def main():
 
 
 def get_slide_info(pptx_path: Path) -> list[dict]:
-    """Get slide filenames and hidden status in presentation order.
-
-    Returns list of dicts with 'name' and 'hidden' keys.
-    """
     with zipfile.ZipFile(pptx_path, "r") as zf:
-        # Read presentation.xml.rels to get rId -> slide filename mapping
         rels_content = zf.read("ppt/_rels/presentation.xml.rels").decode("utf-8")
         rels_dom = defusedxml.minidom.parseString(rels_content)
 
@@ -114,7 +105,6 @@ def get_slide_info(pptx_path: Path) -> list[dict]:
             if "slide" in rel_type and target.startswith("slides/"):
                 rid_to_slide[rid] = target.replace("slides/", "")
 
-        # Read presentation.xml to get slide order and hidden status
         pres_content = zf.read("ppt/presentation.xml").decode("utf-8")
         pres_dom = defusedxml.minidom.parseString(pres_content)
 
@@ -122,7 +112,6 @@ def get_slide_info(pptx_path: Path) -> list[dict]:
         for sld_id in pres_dom.getElementsByTagName("p:sldId"):
             rid = sld_id.getAttribute("r:id")
             if rid in rid_to_slide:
-                # Check if slide is hidden (show="0")
                 hidden = sld_id.getAttribute("show") == "0"
                 slides.append({"name": rid_to_slide[rid], "hidden": hidden})
 
@@ -134,11 +123,6 @@ def build_slide_list(
     visible_images: list[Path],
     temp_dir: Path,
 ) -> list[tuple[Path, str]]:
-    """Build list of (image_path, slide_name) tuples.
-
-    Hidden slides get placeholder images.
-    """
-    # Get placeholder size from first visible image
     if visible_images:
         with Image.open(visible_images[0]) as img:
             placeholder_size = img.size
@@ -150,13 +134,11 @@ def build_slide_list(
 
     for info in slide_info:
         if info["hidden"]:
-            # Create placeholder for hidden slide
             placeholder_path = temp_dir / f"hidden-{info['name']}.jpg"
             placeholder_img = create_hidden_placeholder(placeholder_size)
             placeholder_img.save(placeholder_path, "JPEG")
             slides.append((placeholder_path, f"{info['name']} (hidden)"))
         else:
-            # Use visible image
             if visible_idx < len(visible_images):
                 slides.append((visible_images[visible_idx], info["name"]))
                 visible_idx += 1
@@ -165,7 +147,6 @@ def build_slide_list(
 
 
 def create_hidden_placeholder(size: tuple[int, int]) -> Image.Image:
-    """Create placeholder image for hidden slides (gray with X pattern)."""
     img = Image.new("RGB", size, color="#F0F0F0")
     draw = ImageDraw.Draw(img)
     line_width = max(5, min(size) // 100)
@@ -175,10 +156,8 @@ def create_hidden_placeholder(size: tuple[int, int]) -> Image.Image:
 
 
 def convert_to_images(pptx_path: Path, temp_dir: Path) -> list[Path]:
-    """Convert PowerPoint to images via PDF."""
     pdf_path = temp_dir / f"{pptx_path.stem}.pdf"
 
-    # Convert to PDF
     result = subprocess.run(
         [
             "soffice",
@@ -196,7 +175,6 @@ def convert_to_images(pptx_path: Path, temp_dir: Path) -> list[Path]:
     if result.returncode != 0 or not pdf_path.exists():
         raise RuntimeError("PDF conversion failed")
 
-    # Convert PDF to images
     result = subprocess.run(
         [
             "pdftoppm",
@@ -221,7 +199,6 @@ def create_grids(
     width: int,
     output_path: Path,
 ) -> list[str]:
-    """Create thumbnail grids, max cols×(cols+1) images per grid."""
     max_per_grid = cols * (cols + 1)
     grid_files = []
 
@@ -250,21 +227,17 @@ def create_grid(
     cols: int,
     width: int,
 ) -> Image.Image:
-    """Create a single thumbnail grid."""
     font_size = int(width * FONT_SIZE_RATIO)
     label_padding = int(font_size * LABEL_PADDING_RATIO)
 
-    # Get dimensions from first image
     with Image.open(slides[0][0]) as img:
         aspect = img.height / img.width
     height = int(width * aspect)
 
-    # Calculate grid size
     rows = (len(slides) + cols - 1) // cols
     grid_w = cols * width + (cols + 1) * GRID_PADDING
     grid_h = rows * (height + font_size + label_padding * 2) + (rows + 1) * GRID_PADDING
 
-    # Create grid
     grid = Image.new("RGB", (grid_w, grid_h), "white")
     draw = ImageDraw.Draw(grid)
 
@@ -273,7 +246,6 @@ def create_grid(
     except Exception:
         font = ImageFont.load_default()
 
-    # Place thumbnails
     for i, (img_path, slide_name) in enumerate(slides):
         row, col = i // cols, i % cols
         x = col * width + (col + 1) * GRID_PADDING
@@ -281,7 +253,6 @@ def create_grid(
             row * (height + font_size + label_padding * 2) + (row + 1) * GRID_PADDING
         )
 
-        # Add slide filename label
         label = slide_name
         bbox = draw.textbbox((0, 0), label, font=font)
         text_w = bbox[2] - bbox[0]
@@ -292,7 +263,6 @@ def create_grid(
             font=font,
         )
 
-        # Add thumbnail
         y_thumbnail = y_base + label_padding + font_size + label_padding
 
         with Image.open(img_path) as img:
@@ -302,7 +272,6 @@ def create_grid(
             ty = y_thumbnail + (height - h) // 2
             grid.paste(img, (tx, ty))
 
-            # Add border
             if BORDER_WIDTH > 0:
                 draw.rectangle(
                     [

package/skills/xlsx/SKILL.md

@@ -4,29 +4,6 @@ description: "Use this skill any time a spreadsheet file is the primary input or
 license: Proprietary. LICENSE.txt has complete terms
 ---
 
-# Excel / Spreadsheet Skill
-
-## IMPORTANT: Save to Desktop
-
-**Always save created `.xlsx` and `.csv` files to `~/Desktop/`** (e.g. `~/Desktop/spreadsheet.xlsx`). Never save to the agent workspace or hidden directories — the user needs easy access to the file.
-
-## CRITICAL: Integration Priority
-
-### 1. `lemon-sheets` CLI (For Google Sheets)
-If user wants a Google Sheet (shareable, collaborative), use `lemon-sheets`:
-- `lemon-sheets create "Title"` - Create a new sheet
-- `lemon-sheets read <id>` - Read a spreadsheet
-- `lemon-sheets update <id>` - Update cell values
-- `lemon-sheets append <id>` - Add rows
-
-### 2. Local XLSX (For Files)
-If user wants a local `.xlsx` file, or `lemon-sheets` is not connected, use the local creation methods below.
-
-### 3. Browser (LAST RESORT)
-Only if `lemon-sheets` CLI fails AND user explicitly requests Google Sheets in browser.
-
----
-
 # Requirements for Outputs
 
 ## All Excel files
@@ -114,7 +91,7 @@ df.info()      # Column info
 df.describe()  # Statistics
 
 # Write Excel
-df.to_excel(os.path.expanduser('~/Desktop/output.xlsx'), index=False)
+df.to_excel('output.xlsx', index=False)
 ```
 
 ## Excel File Workflows
@@ -197,7 +174,7 @@ sheet['A1'].alignment = Alignment(horizontal='center')
 # Column width
 sheet.column_dimensions['A'].width = 20
 
-wb.save(os.path.expanduser('~/Desktop/output.xlsx'))
+wb.save('output.xlsx')
 ```
 
 ### Editing existing Excel files
@@ -224,7 +201,7 @@ sheet.delete_cols(3)  # Delete column 3
 new_sheet = wb.create_sheet('NewSheet')
 new_sheet['A1'] = 'Data'
 
-wb.save(os.path.expanduser('~/Desktop/modified.xlsx'))
+wb.save('modified.xlsx')
 ```
 
 ## Recalculating formulas

package/skills/xlsx/scripts/office/helpers/merge_runs.py

@@ -14,14 +14,6 @@ import defusedxml.minidom
 
 
 def merge_runs(input_dir: str) -> tuple[int, str]:
-    """Merge adjacent runs in document.xml.
-
-    Args:
-        input_dir: Path to unpacked DOCX directory
-
-    Returns:
-        (merge_count, message)
-    """
     doc_xml = Path(input_dir) / "word" / "document.xml"
 
     if not doc_xml.exists():
@@ -31,14 +23,11 @@ def merge_runs(input_dir: str) -> tuple[int, str]:
         dom = defusedxml.minidom.parseString(doc_xml.read_text(encoding="utf-8"))
         root = dom.documentElement
 
-        # Clean up elements that block merging
         _remove_elements(root, "proofErr")
         _strip_run_rsid_attrs(root)
 
-        # Find all containers that have runs
         containers = {run.parentNode for run in _find_elements(root, "r")}
 
-        # Merge runs in each container
         merge_count = 0
         for container in containers:
             merge_count += _merge_runs_in(container)
@@ -50,11 +39,9 @@ def merge_runs(input_dir: str) -> tuple[int, str]:
         return 0, f"Error: {e}"
 
 
-# --- Element helpers ---
 
 
 def _find_elements(root, tag: str) -> list:
-    """Find all elements matching tag name (with or without namespace)."""
     results = []
 
     def traverse(node):
@@ -70,7 +57,6 @@ def _find_elements(root, tag: str) -> list:
 
 
 def _get_child(parent, tag: str):
-    """Get first child element matching tag name."""
     for child in parent.childNodes:
         if child.nodeType == child.ELEMENT_NODE:
             name = child.localName or child.tagName
@@ -80,7 +66,6 @@ def _get_child(parent, tag: str):
 
 
 def _get_children(parent, tag: str) -> list:
-    """Get all direct child elements matching tag name."""
     results = []
     for child in parent.childNodes:
         if child.nodeType == child.ELEMENT_NODE:
@@ -91,7 +76,6 @@ def _get_children(parent, tag: str) -> list:
 
 
 def _is_adjacent(elem1, elem2) -> bool:
-    """Check if two elements are adjacent (only whitespace between them)."""
     node = elem1.nextSibling
     while node:
         if node == elem2:
@@ -104,34 +88,28 @@ def _is_adjacent(elem1, elem2) -> bool:
     return False
 
 
-# --- Cleanup functions ---
 
 
 def _remove_elements(root, tag: str):
-    """Remove all elements matching tag name."""
     for elem in _find_elements(root, tag):
         if elem.parentNode:
             elem.parentNode.removeChild(elem)
 
 
 def _strip_run_rsid_attrs(root):
-    """Remove rsid attributes from all run elements."""
     for run in _find_elements(root, "r"):
         for attr in list(run.attributes.values()):
             if "rsid" in attr.name.lower():
                 run.removeAttribute(attr.name)
 
 
-# --- Merge functions ---
 
 
 def _merge_runs_in(container) -> int:
-    """Merge adjacent runs with identical formatting in a container element."""
     merge_count = 0
     run = _first_child_run(container)
 
     while run:
-        # Absorb adjacent runs with same formatting
         while True:
             next_elem = _next_element_sibling(run)
             if next_elem and _is_run(next_elem) and _can_merge(run, next_elem):
@@ -148,7 +126,6 @@ def _merge_runs_in(container) -> int:
 
 
 def _first_child_run(container):
-    """Get the first run child of a container."""
     for child in container.childNodes:
         if child.nodeType == child.ELEMENT_NODE and _is_run(child):
             return child
@@ -156,7 +133,6 @@ def _first_child_run(container):
 
 
 def _next_element_sibling(node):
-    """Get the next element sibling, skipping text/whitespace nodes."""
     sibling = node.nextSibling
     while sibling:
         if sibling.nodeType == sibling.ELEMENT_NODE:
@@ -166,25 +142,21 @@ def _next_element_sibling(node):
 
 
 def _next_sibling_run(node):
-    """Get the next sibling that is a run element."""
     sibling = node.nextSibling
     while sibling:
         if sibling.nodeType == sibling.ELEMENT_NODE:
             if _is_run(sibling):
                 return sibling
-            # Skip non-run elements (bookmarks, etc.) but keep looking
         sibling = sibling.nextSibling
     return None
 
 
 def _is_run(node) -> bool:
-    """Check if node is a run element."""
     name = node.localName or node.tagName
     return name == "r" or name.endswith(":r")
 
 
 def _can_merge(run1, run2) -> bool:
-    """Check if two runs have identical formatting."""
     rpr1 = _get_child(run1, "rPr")
     rpr2 = _get_child(run2, "rPr")
 
@@ -192,11 +164,10 @@ def _can_merge(run1, run2) -> bool:
         return False
     if rpr1 is None:
         return True
-    return rpr1.toxml() == rpr2.toxml()  # type: ignore
+    return rpr1.toxml() == rpr2.toxml()  
 
 
 def _merge_run_content(target, source):
-    """Move content from source run to target run (excluding rPr)."""
     for child in list(source.childNodes):
         if child.nodeType == child.ELEMENT_NODE:
             name = child.localName or child.tagName
@@ -205,10 +176,8 @@ def _merge_run_content(target, source):
 
 
 def _consolidate_text(run):
-    """Merge adjacent <w:t> elements within a run."""
     t_elements = _get_children(run, "t")
 
-    # Work backwards to safely remove elements
     for i in range(len(t_elements) - 1, 0, -1):
         curr, prev = t_elements[i], t_elements[i - 1]
 
@@ -222,7 +191,6 @@ def _consolidate_text(run):
             else:
                 prev.appendChild(run.ownerDocument.createTextNode(merged))
 
-            # Preserve whitespace if needed
             if merged.startswith(" ") or merged.endswith(" "):
                 prev.setAttribute("xml:space", "preserve")
             elif prev.hasAttribute("xml:space"):