@preapexis/piexis 0.1.2

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

@@ -0,0 +1,299 @@
+"""
+Validator for tracked changes in Word documents.
+
+Detects untracked edits in word/document.xml: text that differs from the
+original without a <w:ins>/<w:del> wrapper recording it. The tracked changes
+that are new relative to the original are undone, and the result is compared
+against the original; whatever text still differs was edited without being
+tracked.
+
+Only the document body is compared. Headers, footers, footnotes and endnotes
+are separate parts and are not checked.
+"""
+
+import subprocess
+import tempfile
+import zipfile
+from pathlib import Path
+
+import defusedxml.ElementTree as ET
+from defusedxml.common import DefusedXmlException
+
+from helpers import rendered_text, safe_extract
+
+
+class RedliningValidator:
+
+    def __init__(self, unpacked_dir, original_docx, verbose=False):
+        self.unpacked_dir = Path(unpacked_dir)
+        self.original_docx = Path(original_docx)
+        self.verbose = verbose
+        self.namespaces = {
+            "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+        }
+
+    def repair(self) -> int:
+        return 0
+
+    def validate(self):
+        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
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            try:
+                with zipfile.ZipFile(self.original_docx, "r") as zip_ref:
+                    safe_extract(zip_ref, temp_path)
+            except Exception as e:
+                print(f"FAILED - Error unpacking original docx: {e}")
+                return False
+
+            original_file = temp_path / "word" / "document.xml"
+            if not original_file.exists():
+                print(
+                    f"FAILED - Original document.xml not found in {self.original_docx}"
+                )
+                return False
+
+            try:
+                modified_tree = ET.parse(modified_file)
+                modified_root = modified_tree.getroot()
+                original_tree = ET.parse(original_file)
+                original_root = original_tree.getroot()
+            except (ET.ParseError, DefusedXmlException) as e:
+                print(f"FAILED - Error parsing XML files: {e}")
+                return False
+
+            new_changes = self._new_tracked_changes(original_root, modified_root)
+            self._remove_tracked_changes(modified_root, new_changes)
+
+            modified_text = self._extract_text_content(modified_root)
+            original_text = self._extract_text_content(original_root)
+
+            if modified_text != original_text:
+                error_message = self._generate_detailed_diff(
+                    original_text, modified_text
+                )
+                print(error_message)
+                return False
+
+            if self.verbose:
+                print(
+                    f"PASSED - All {len(new_changes)} change(s) against the original "
+                    "are properly tracked"
+                )
+            return True
+
+    def _tracked_change_elements(self, root):
+        ins_tag = f"{{{self.namespaces['w']}}}ins"
+        del_tag = f"{{{self.namespaces['w']}}}del"
+        return [elem for elem in root.iter() if elem.tag in (ins_tag, del_tag)]
+
+    def _rendered_text(self, elem):
+        preserve = elem.get("{http://www.w3.org/XML/1998/namespace}space") == "preserve"
+        return rendered_text(elem.text or "", preserve)
+
+    def _text_elements(self, elem):
+        w = self.namespaces["w"]
+        return [
+            node
+            for node in elem.iter()
+            if node.tag in (f"{{{w}}}t", f"{{{w}}}delText")
+        ]
+
+    def _tracked_change_key(self, elem):
+        w = self.namespaces["w"]
+        text = "".join(self._rendered_text(node) for node in self._text_elements(elem))
+        return (elem.tag, elem.get(f"{{{w}}}author"), elem.get(f"{{{w}}}date"), text)
+
+    def _new_tracked_changes(self, original_root, modified_root):
+        original = self._tracked_change_elements(original_root)
+        modified = self._tracked_change_elements(modified_root)
+
+        pool = {}
+        for elem in original:
+            pool.setdefault(self._tracked_change_key(elem), []).append(elem)
+
+        matched, leftover = set(), []
+        for elem in modified:
+            bucket = pool.get(self._tracked_change_key(elem))
+            if bucket:
+                matched.add(bucket.pop())
+            else:
+                leftover.append(elem)
+
+        def group(elem):
+            return self._tracked_change_key(elem)[:3]
+
+        def text_of(elems):
+            return "".join(self._tracked_change_key(e)[3] for e in elems)
+
+        unmatched_original = {}
+        for elem in original:
+            if elem not in matched:
+                unmatched_original.setdefault(group(elem), []).append(elem)
+
+        by_group = {}
+        for elem in leftover:
+            by_group.setdefault(group(elem), []).append(elem)
+
+        new = set()
+        for key, elems in by_group.items():
+            rebuilt = text_of(elems)
+            if rebuilt and rebuilt == text_of(unmatched_original.get(key, [])):
+                continue  
+            new.update(elems)
+        return new
+
+    def _generate_detailed_diff(self, original_text, modified_text):
+        error_parts = [
+            "FAILED - Document text doesn't match after removing the tracked changes",
+            "",
+            "Likely causes:",
+            "  1. Modified text inside another author's <w:ins> or <w:del> tags",
+            "  2. Made edits without proper tracked changes",
+            "  3. Didn't nest <w:del> inside <w:ins> when deleting another's insertion",
+            "  4. Rewrote another author's <w:ins>/<w:del> and changed its text on",
+            "     the way. A tracked change from the original is recognised by its",
+            "     author, date and text; anything that doesn't reproduce one exactly",
+            "     reads as new, and the text it carried is reported missing.",
+            "",
+            "For pre-redlined documents, use correct patterns:",
+            "  - To reject another's INSERTION: Nest <w:del> inside their <w:ins>",
+            "  - To reject PART of one: nest <w:del> around only the runs you reject.",
+            "    Their <w:ins> may be split around it, so long as the pieces keep",
+            "    their author and date and still spell out the same text.",
+            "  - To restore another's DELETION: Add new <w:ins> AFTER their <w:del>",
+            "",
+        ]
+
+        git_diff = self._get_git_word_diff(original_text, modified_text)
+        if git_diff:
+            error_parts.extend(["Differences:", "============", git_diff])
+        else:
+            error_parts.append("Unable to generate word diff (git not available)")
+
+        return "\n".join(error_parts)
+
+    def _get_git_word_diff(self, original_text, modified_text):
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir)
+
+                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")
+
+                result = subprocess.run(
+                    [
+                        "git",
+                        "diff",
+                        "--word-diff=plain",
+                        "--word-diff-regex=.",  
+                        "-U0",  
+                        "--no-index",
+                        str(original_file),
+                        str(modified_file),
+                    ],
+                    capture_output=True,
+                    text=True,
+                )
+
+                if result.stdout.strip():
+                    lines = result.stdout.split("\n")
+                    content_lines = []
+                    in_content = False
+                    for line in lines:
+                        if line.startswith("@@"):
+                            in_content = True
+                            continue
+                        if in_content and line.strip():
+                            content_lines.append(line)
+
+                    if content_lines:
+                        return "\n".join(content_lines)
+
+                result = subprocess.run(
+                    [
+                        "git",
+                        "diff",
+                        "--word-diff=plain",
+                        "-U0",  
+                        "--no-index",
+                        str(original_file),
+                        str(modified_file),
+                    ],
+                    capture_output=True,
+                    text=True,
+                )
+
+                if result.stdout.strip():
+                    lines = result.stdout.split("\n")
+                    content_lines = []
+                    in_content = False
+                    for line in lines:
+                        if line.startswith("@@"):
+                            in_content = True
+                            continue
+                        if in_content and line.strip():
+                            content_lines.append(line)
+                    return "\n".join(content_lines)
+
+        except (subprocess.CalledProcessError, FileNotFoundError, Exception):
+            pass
+
+        return None
+
+    def _remove_tracked_changes(self, root, targets):
+        ins_tag = f"{{{self.namespaces['w']}}}ins"
+        del_tag = f"{{{self.namespaces['w']}}}del"
+
+        for parent in root.iter():
+            to_remove = []
+            for child in parent:
+                if child.tag == ins_tag and child in targets:
+                    to_remove.append(child)
+            for elem in to_remove:
+                parent.remove(elem)
+
+        deltext_tag = f"{{{self.namespaces['w']}}}delText"
+        t_tag = f"{{{self.namespaces['w']}}}t"
+
+        for parent in root.iter():
+            to_process = []
+            for child in parent:
+                if child.tag == del_tag and child in targets:
+                    to_process.append((child, list(parent).index(child)))
+
+            for del_elem, del_index in reversed(to_process):
+                for elem in del_elem.iter():
+                    if elem.tag == deltext_tag:
+                        elem.tag = t_tag
+
+                for child in reversed(list(del_elem)):
+                    parent.insert(del_index, child)
+                parent.remove(del_elem)
+
+    def _extract_text_content(self, root):
+        p_tag = f"{{{self.namespaces['w']}}}p"
+        t_tag = f"{{{self.namespaces['w']}}}t"
+
+        paragraphs = []
+        for p_elem in root.findall(f".//{p_tag}"):
+            text_parts = []
+            for t_elem in p_elem.findall(f".//{t_tag}"):
+                text_parts.append(self._rendered_text(t_elem))
+            paragraph_text = "".join(text_parts)
+            if paragraph_text:
+                paragraphs.append(paragraph_text)
+
+        return "\n".join(paragraphs)
+
+
+if __name__ == "__main__":
+    raise RuntimeError("This module should not be run directly.")

package/skills/pptx/scripts/thumbnail.py

@@ -0,0 +1,311 @@
+"""Create thumbnail grids from PowerPoint presentation slides.
+
+Creates a grid layout of slide thumbnails for quick visual analysis.
+Labels each thumbnail with its XML filename (e.g., slide1.xml).
+Hidden slides are shown with a placeholder pattern.
+
+Usage:
+    python thumbnail.py input.pptx [output_prefix] [--cols N]
+
+Examples:
+    python thumbnail.py presentation.pptx
+    # Creates: thumbnails.jpg
+
+    python thumbnail.py template.pptx grid --cols 4
+    # Creates: grid.jpg (or grid-1.jpg, grid-2.jpg for large decks)
+"""
+
+import argparse
+import posixpath
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+import defusedxml.minidom
+from defusedxml import ElementTree
+from office.helpers import SLIDE_REL_TYPE, opc_target
+from office.soffice import run_soffice
+from PIL import Image, ImageDraw, ImageFont
+
+
+THUMBNAIL_WIDTH = 300
+CONVERSION_DPI = 100
+MAX_COLS = 6
+DEFAULT_COLS = 3
+JPEG_QUALITY = 95
+GRID_PADDING = 20
+BORDER_WIDTH = 2
+FONT_SIZE_RATIO = 0.10
+LABEL_PADDING_RATIO = 0.4
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create thumbnail grids from PowerPoint slides."
+    )
+    parser.add_argument("input", help="Input PowerPoint file (.pptx)")
+    parser.add_argument(
+        "output_prefix",
+        nargs="?",
+        default="thumbnails",
+        help="Output prefix for image files (default: thumbnails)",
+    )
+    parser.add_argument(
+        "--cols",
+        type=int,
+        default=DEFAULT_COLS,
+        help=f"Number of columns (default: {DEFAULT_COLS}, max: {MAX_COLS})",
+    )
+
+    args = parser.parse_args()
+
+    cols = min(args.cols, MAX_COLS)
+    if args.cols > MAX_COLS:
+        print(f"Warning: Columns limited to {MAX_COLS}")
+
+    input_path = Path(args.input)
+    if not input_path.exists() or input_path.suffix.lower() != ".pptx":
+        print(f"Error: Invalid PowerPoint file: {args.input}", file=sys.stderr)
+        sys.exit(1)
+
+    output_path = Path(f"{args.output_prefix}.jpg")
+
+    try:
+        slide_info = get_slide_info(input_path)
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            visible_images = convert_to_images(input_path, temp_path)
+
+            if not visible_images and not any(s["hidden"] for s in slide_info):
+                print("Error: No slides found", file=sys.stderr)
+                sys.exit(1)
+
+            slides = build_slide_list(slide_info, visible_images, temp_path)
+
+            grid_files = create_grids(slides, cols, THUMBNAIL_WIDTH, output_path)
+
+            print(f"Created {len(grid_files)} grid(s):")
+            for grid_file in grid_files:
+                print(f"  {grid_file}")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def _is_hidden(zf: zipfile.ZipFile, part: str) -> bool:
+    try:
+        with zf.open(part) as f:
+            for _, root in ElementTree.iterparse(f, events=("start",)):
+                return root.get("show") in ("0", "false")  
+    except (KeyError, ElementTree.ParseError):
+        return False
+    return False
+
+
+def get_slide_info(pptx_path: Path) -> list[dict]:
+    with zipfile.ZipFile(pptx_path, "r") as zf:
+        rels_content = zf.read("ppt/_rels/presentation.xml.rels").decode("utf-8")
+        rels_dom = defusedxml.minidom.parseString(rels_content)
+
+        rid_to_part = {}
+        for rel in rels_dom.getElementsByTagName("Relationship"):
+            if rel.getAttribute("Type") != SLIDE_REL_TYPE:
+                continue
+            part = opc_target(
+                rel.getAttribute("Target"),
+                "ppt/presentation.xml",
+                rel.getAttribute("TargetMode"),
+            )
+            if part is not None:
+                rid_to_part[rel.getAttribute("Id")] = part
+
+        pres_content = zf.read("ppt/presentation.xml").decode("utf-8")
+        pres_dom = defusedxml.minidom.parseString(pres_content)
+
+        present = set(zf.namelist())
+
+        slides = []
+        for sld_id in pres_dom.getElementsByTagName("p:sldId"):
+            part = rid_to_part.get(sld_id.getAttribute("r:id"))
+            if part is not None and part in present:
+                slides.append(
+                    {"name": posixpath.basename(part), "hidden": _is_hidden(zf, part)}
+                )
+
+        return slides
+
+
+def build_slide_list(
+    slide_info: list[dict],
+    visible_images: list[Path],
+    temp_dir: Path,
+) -> list[tuple[Path, str]]:
+    visible_count = sum(1 for info in slide_info if not info["hidden"])
+    rendered_hidden = len(visible_images) == len(slide_info) != visible_count
+
+    if not rendered_hidden and visible_count != len(visible_images):
+        raise ValueError(
+            f"LibreOffice rendered {len(visible_images)} page(s) for {visible_count} "
+            f"visible slide(s) of {len(slide_info)}; thumbnails would be mislabeled"
+        )
+
+    if visible_images:
+        with Image.open(visible_images[0]) as img:
+            placeholder_size = img.size
+    else:
+        placeholder_size = (1920, 1080)
+
+    slides = []
+    visible_idx = 0
+
+    for info in slide_info:
+        if info["hidden"] and not rendered_hidden:
+            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:
+            label = f"{info['name']} (hidden)" if info["hidden"] else info["name"]
+            slides.append((visible_images[visible_idx], label))
+            visible_idx += 1
+
+    return slides
+
+
+def create_hidden_placeholder(size: tuple[int, int]) -> Image.Image:
+    img = Image.new("RGB", size, color="#F0F0F0")
+    draw = ImageDraw.Draw(img)
+    line_width = max(5, min(size) // 100)
+    draw.line([(0, 0), size], fill="#CCCCCC", width=line_width)
+    draw.line([(size[0], 0), (0, size[1])], fill="#CCCCCC", width=line_width)
+    return img
+
+
+def convert_to_images(pptx_path: Path, temp_dir: Path) -> list[Path]:
+    pdf_path = temp_dir / f"{pptx_path.stem}.pdf"
+
+    result = run_soffice(
+        ["--headless", "--convert-to", "pdf", "--outdir", str(temp_dir), str(pptx_path)],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0 or not pdf_path.exists():
+        detail = (result.stderr or result.stdout or "").strip()
+        raise RuntimeError(f"PDF conversion failed: {detail}" if detail else "PDF conversion failed")
+
+    result = subprocess.run(
+        [
+            "pdftoppm",
+            "-jpeg",
+            "-r",
+            str(CONVERSION_DPI),
+            str(pdf_path),
+            str(temp_dir / "slide"),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError("Image conversion failed")
+
+    return sorted(temp_dir.glob("slide-*.jpg"))
+
+
+def create_grids(
+    slides: list[tuple[Path, str]],
+    cols: int,
+    width: int,
+    output_path: Path,
+) -> list[str]:
+    max_per_grid = cols * (cols + 1)
+    grid_files = []
+
+    for chunk_idx, start_idx in enumerate(range(0, len(slides), max_per_grid)):
+        end_idx = min(start_idx + max_per_grid, len(slides))
+        chunk_slides = slides[start_idx:end_idx]
+
+        grid = create_grid(chunk_slides, cols, width)
+
+        if len(slides) <= max_per_grid:
+            grid_filename = output_path
+        else:
+            stem = output_path.stem
+            suffix = output_path.suffix
+            grid_filename = output_path.parent / f"{stem}-{chunk_idx + 1}{suffix}"
+
+        grid_filename.parent.mkdir(parents=True, exist_ok=True)
+        grid.save(str(grid_filename), quality=JPEG_QUALITY)
+        grid_files.append(str(grid_filename))
+
+    return grid_files
+
+
+def create_grid(
+    slides: list[tuple[Path, str]],
+    cols: int,
+    width: int,
+) -> Image.Image:
+    font_size = int(width * FONT_SIZE_RATIO)
+    label_padding = int(font_size * LABEL_PADDING_RATIO)
+
+    with Image.open(slides[0][0]) as img:
+        aspect = img.height / img.width
+    height = int(width * aspect)
+
+    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
+
+    grid = Image.new("RGB", (grid_w, grid_h), "white")
+    draw = ImageDraw.Draw(grid)
+
+    try:
+        font = ImageFont.load_default(size=font_size)
+    except Exception:
+        font = ImageFont.load_default()
+
+    for i, (img_path, slide_name) in enumerate(slides):
+        row, col = i // cols, i % cols
+        x = col * width + (col + 1) * GRID_PADDING
+        y_base = (
+            row * (height + font_size + label_padding * 2) + (row + 1) * GRID_PADDING
+        )
+
+        label = slide_name
+        bbox = draw.textbbox((0, 0), label, font=font)
+        text_w = bbox[2] - bbox[0]
+        draw.text(
+            (x + (width - text_w) // 2, y_base + label_padding),
+            label,
+            fill="black",
+            font=font,
+        )
+
+        y_thumbnail = y_base + label_padding + font_size + label_padding
+
+        with Image.open(img_path) as img:
+            img.thumbnail((width, height), Image.Resampling.LANCZOS)
+            w, h = img.size
+            tx = x + (width - w) // 2
+            ty = y_thumbnail + (height - h) // 2
+            grid.paste(img, (tx, ty))
+
+            if BORDER_WIDTH > 0:
+                draw.rectangle(
+                    [
+                        (tx - BORDER_WIDTH, ty - BORDER_WIDTH),
+                        (tx + w + BORDER_WIDTH - 1, ty + h + BORDER_WIDTH - 1),
+                    ],
+                    outline="gray",
+                    width=BORDER_WIDTH,
+                )
+
+    return grid
+
+
+if __name__ == "__main__":
+    main()

package/skills/safe-refactor/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: safe-refactor
+description: Restructure code while preserving behavior. Use for extraction, consolidation, ownership moves, or cleanup where verification must bracket structural edits.
+---
+
+# Safe refactor
+
+Define behavior-preservation boundary and establish verification before structural edits.
+
+- Keep feature changes outside refactor.
+- Move one ownership boundary at a time.
+- Preserve public interfaces, failure behavior, ordering, and compatibility unless explicitly scoped.
+- Keep intermediate states buildable and testable.
+- Avoid dependency or configuration growth without correctness need.
+
+Run same proof after change. Stop when behavior matches and requested structure is achieved.

package/skills/safe-refactor/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Safe Refactor"
+  short_description: "Preserve behavior through structural change"
+  default_prompt: "Use $safe-refactor to restructure this code while preserving behavior."

package/skills/tdd/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: tdd
+description: Use for test-first feature or bug work, explicit red-green-refactor requests, or when the user asks to design tests before implementation. Do not use merely because a change needs ordinary regression coverage.
+---
+
+# Test-Driven Development
+
+Use short vertical slices: one observable behavior, one failing test, the minimum implementation, then the next behavior.
+
+1. Read relevant project terminology, ADRs, and existing test conventions.
+2. Choose the highest practical public seam. Confirm the seam with the user only when it is consequential or ambiguous; otherwise state the choice and proceed.
+3. Write a test that fails for the requested behavior and derives expected values from the spec or a known-good example.
+4. Add only enough implementation to make that test pass.
+5. Repeat for the next behavior. Refactor separately once behavior is covered.
+
+Tests should verify externally observable behavior, survive internal refactors, and avoid tautological expectations. Mock only true system boundaries; prefer real local implementations or test databases when practical.
+
+Do not write a broad speculative test suite before learning from the first slice. Run focused tests after each slice and the relevant wider gate before completion.

package/skills/tdd/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "TDD"
+  short_description: "Test-driven red-green-refactor"