cli-jaw 0.1.6 → 0.1.8

package/skills_ref/pptx/scripts/thumbnail.py

@@ -1,289 +0,0 @@
-"""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 subprocess
-import sys
-import tempfile
-import zipfile
-from pathlib import Path
-
-import defusedxml.minidom
-from office.soffice import get_soffice_env
-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 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_slide = {}
-        for rel in rels_dom.getElementsByTagName("Relationship"):
-            rid = rel.getAttribute("Id")
-            target = rel.getAttribute("Target")
-            rel_type = rel.getAttribute("Type")
-            if "slide" in rel_type and target.startswith("slides/"):
-                rid_to_slide[rid] = target.replace("slides/", "")
-
-        pres_content = zf.read("ppt/presentation.xml").decode("utf-8")
-        pres_dom = defusedxml.minidom.parseString(pres_content)
-
-        slides = []
-        for sld_id in pres_dom.getElementsByTagName("p:sldId"):
-            rid = sld_id.getAttribute("r:id")
-            if rid in rid_to_slide:
-                hidden = sld_id.getAttribute("show") == "0"
-                slides.append({"name": rid_to_slide[rid], "hidden": hidden})
-
-        return slides
-
-
-def build_slide_list(
-    slide_info: list[dict],
-    visible_images: list[Path],
-    temp_dir: Path,
-) -> list[tuple[Path, str]]:
-    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"]:
-            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:
-            if visible_idx < len(visible_images):
-                slides.append((visible_images[visible_idx], info["name"]))
-                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 = subprocess.run(
-        [
-            "soffice",
-            "--headless",
-            "--convert-to",
-            "pdf",
-            "--outdir",
-            str(temp_dir),
-            str(pptx_path),
-        ],
-        capture_output=True,
-        text=True,
-        env=get_soffice_env(),
-    )
-    if result.returncode != 0 or not pdf_path.exists():
-        raise RuntimeError("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_ref/property-based-testing/.claude-plugin/plugin.json

@@ -1,9 +0,0 @@
-{
-  "name": "property-based-testing",
-  "version": "1.1.0",
-  "description": "Property-based testing guidance for multiple languages and smart contracts",
-  "author": {
-    "name": "Henrik Brodin",
-    "url": "https://github.com/trailofbits"
-  }
-}

package/skills_ref/property-based-testing/README.md

@@ -1,47 +0,0 @@
-# Property-Based Testing
-
-Property-based testing guidance for multiple languages and smart contracts.
-
-## Installation
-
-This plugin is part of the Trail of Bits Skills marketplace.
-
-### Via Marketplace (Recommended)
-
-```
-/plugin marketplace add trailofbits/skills
-/plugin menu
-```
-
-Then select the `property-based-testing` plugin to install.
-
-### Manual Installation
-
-```
-/plugin install trailofbits/skills/plugins/property-based-testing
-```
-
-## What's Included
-
-This plugin provides a skill that helps Claude Code proactively suggest and write property-based tests when it detects suitable patterns in your code:
-
-- **Serialization pairs**: encode/decode, serialize/deserialize, toJSON/fromJSON
-- **Parsers**: URL parsing, config parsing, protocol parsing
-- **Normalization**: normalize, sanitize, clean, canonicalize
-- **Validators**: is_valid, validate, check_*
-- **Data structures**: Custom collections with add/remove/get operations
-- **Mathematical/algorithmic**: Pure functions, sorting, ordering
-- **Smart contracts**: Solidity/Vyper contracts, token operations, state invariants
-
-## Supported Languages
-
-- Python (Hypothesis)
-- JavaScript/TypeScript (fast-check)
-- Rust (proptest, quickcheck)
-- Go (rapid, gopter)
-- Java (jqwik)
-- Scala (ScalaCheck)
-- Solidity/Vyper (Echidna, Medusa)
-- And many more...
-
-See `skills/property-based-testing/references/libraries.md` for the complete list.

package/skills_ref/property-based-testing/skills/property-based-testing/README.md

@@ -1,88 +0,0 @@
-# Property-Based Testing Skill
-
-A Claude Code skill that provides guidance for property-based testing (PBT) across multiple programming languages and smart contract development.
-
-## What This Skill Does
-
-When activated, this skill helps Claude:
-
-- **Detect PBT opportunities** - Recognizes patterns like encode/decode pairs, validators, normalizers, pure functions, and smart contract invariants
-- **Generate property-based tests** - Creates tests with appropriate strategies, properties, and edge cases
-- **Review existing PBT tests** - Identifies issues like tautological properties, vacuous tests, and weak assertions
-- **Design with properties** - Uses Property-Driven Development to define specifications before implementation
-- **Refactor for testability** - Suggests code changes that enable stronger property testing
-
-## Supported Languages
-
-| Language | Library | Notes |
-|----------|---------|-------|
-| Python | Hypothesis | |
-| JavaScript/TypeScript | fast-check | |
-| Rust | proptest | Also: quickcheck |
-| Go | rapid | Also: gopter |
-| Java | jqwik | |
-| Scala | ScalaCheck | |
-| C# | FsCheck | |
-| Elixir | StreamData | |
-| Haskell | QuickCheck | Also: Hedgehog |
-| Clojure | test.check | |
-| Ruby | PropCheck | |
-| Kotlin | Kotest | |
-| Swift | SwiftCheck | Unmaintained |
-| C++ | RapidCheck | |
-
-### Smart Contract Testing
-
-| Tool | Platform | Description |
-|------|----------|-------------|
-| Echidna | EVM/Solidity | Property-based fuzzer |
-| Medusa | EVM/Solidity | Next-gen parallel fuzzer |
-
-See [secure-contracts.com](https://secure-contracts.com) for tutorials.
-
-## File Structure
-
-```
-property-based-testing/
-├── SKILL.md           # Entry point - detection patterns and routing
-├── README.md          # This file
-└── references/
-    ├── generating.md  # How to write property-based tests
-    ├── reviewing.md   # How to evaluate test quality
-    ├── strategies.md  # Input generation reference
-    ├── design.md      # Property-Driven Development workflow
-    ├── refactoring.md # Making code more testable
-    └── libraries.md   # PBT library reference by language
-```
-
-## Usage
-
-The skill activates automatically when Claude detects relevant patterns:
-
-- Serialization pairs (`encode`/`decode`, `serialize`/`deserialize`)
-- Validators and normalizers
-- Pure functions with clear input/output types
-- Data structure operations
-- Smart contracts (Solidity/Vyper)
-
-You can also invoke it explicitly by asking Claude to use property-based testing.
-
-### Example Prompts
-
-```
-"Write property-based tests for this JSON serializer"
-"Review this Hypothesis test for quality issues"
-"Help me design this feature using properties first"
-"This function is hard to test - how can I refactor it?"
-"Write Echidna invariants for this token contract"
-```
-
-## Property Quick Reference
-
-| Property | Pattern | Use Case |
-|----------|---------|----------|
-| Roundtrip | `decode(encode(x)) == x` | Serialization |
-| Idempotence | `f(f(x)) == f(x)` | Normalization |
-| Invariant | `property(f(x))` holds | Any transformation, smart contracts |
-| Commutativity | `f(a,b) == f(b,a)` | Binary operations |
-| Oracle | `new(x) == reference(x)` | Refactoring |

package/skills_ref/property-based-testing/skills/property-based-testing/SKILL.md

@@ -1,123 +0,0 @@
----
-name: property-based-testing
-description: Provides guidance for property-based testing across multiple languages and smart contracts. Use when writing tests, reviewing code with serialization/validation/parsing patterns, designing features, or when property-based testing would provide stronger coverage than example-based tests.
----
-
-# Property-Based Testing Guide
-
-Use this skill proactively during development when you encounter patterns where PBT provides stronger coverage than example-based tests.
-
-## When to Invoke (Automatic Detection)
-
-**Invoke this skill when you detect:**
-
-- **Serialization pairs**: `encode`/`decode`, `serialize`/`deserialize`, `toJSON`/`fromJSON`, `pack`/`unpack`
-- **Parsers**: URL parsing, config parsing, protocol parsing, string-to-structured-data
-- **Normalization**: `normalize`, `sanitize`, `clean`, `canonicalize`, `format`
-- **Validators**: `is_valid`, `validate`, `check_*` (especially with normalizers)
-- **Data structures**: Custom collections with `add`/`remove`/`get` operations
-- **Mathematical/algorithmic**: Pure functions, sorting, ordering, comparators
-- **Smart contracts**: Solidity/Vyper contracts, token operations, state invariants, access control
-
-**Priority by pattern:**
-
-| Pattern | Property | Priority |
-|---------|----------|----------|
-| encode/decode pair | Roundtrip | HIGH |
-| Pure function | Multiple | HIGH |
-| Validator | Valid after normalize | MEDIUM |
-| Sorting/ordering | Idempotence + ordering | MEDIUM |
-| Normalization | Idempotence | MEDIUM |
-| Builder/factory | Output invariants | LOW |
-| Smart contract | State invariants | HIGH |
-
-## When NOT to Use
-
-Do NOT use this skill for:
-- Simple CRUD operations without transformation logic
-- One-off scripts or throwaway code
-- Code with side effects that cannot be isolated (network calls, database writes)
-- Tests where specific example cases are sufficient and edge cases are well-understood
-- Integration or end-to-end testing (PBT is best for unit/component testing)
-
-## Property Catalog (Quick Reference)
-
-| Property | Formula | When to Use |
-|----------|---------|-------------|
-| **Roundtrip** | `decode(encode(x)) == x` | Serialization, conversion pairs |
-| **Idempotence** | `f(f(x)) == f(x)` | Normalization, formatting, sorting |
-| **Invariant** | Property holds before/after | Any transformation |
-| **Commutativity** | `f(a, b) == f(b, a)` | Binary/set operations |
-| **Associativity** | `f(f(a,b), c) == f(a, f(b,c))` | Combining operations |
-| **Identity** | `f(x, identity) == x` | Operations with neutral element |
-| **Inverse** | `f(g(x)) == x` | encrypt/decrypt, compress/decompress |
-| **Oracle** | `new_impl(x) == reference(x)` | Optimization, refactoring |
-| **Easy to Verify** | `is_sorted(sort(x))` | Complex algorithms |
-| **No Exception** | No crash on valid input | Baseline property |
-
-**Strength hierarchy** (weakest to strongest):
-No Exception → Type Preservation → Invariant → Idempotence → Roundtrip
-
-## Decision Tree
-
-Based on the current task, read the appropriate section:
-
-```
-TASK: Writing new tests
-  → Read [{baseDir}/references/generating.md]({baseDir}/references/generating.md) (test generation patterns and examples)
-  → Then [{baseDir}/references/strategies.md]({baseDir}/references/strategies.md) if input generation is complex
-
-TASK: Designing a new feature
-  → Read [{baseDir}/references/design.md]({baseDir}/references/design.md) (Property-Driven Development approach)
-
-TASK: Code is difficult to test (mixed I/O, missing inverses)
-  → Read [{baseDir}/references/refactoring.md]({baseDir}/references/refactoring.md) (refactoring patterns for testability)
-
-TASK: Reviewing existing PBT tests
-  → Read [{baseDir}/references/reviewing.md]({baseDir}/references/reviewing.md) (quality checklist and anti-patterns)
-
-TASK: Test failed, need to interpret
-  → Read [{baseDir}/references/interpreting-failures.md]({baseDir}/references/interpreting-failures.md) (failure analysis and bug classification)
-
-TASK: Need library reference
-  → Read [{baseDir}/references/libraries.md]({baseDir}/references/libraries.md) (PBT libraries by language, includes smart contract tools)
-```
-
-## How to Suggest PBT
-
-When you detect a high-value pattern while writing tests, **offer PBT as an option**:
-
-> "I notice `encode_message`/`decode_message` is a serialization pair. Property-based testing with a roundtrip property would provide stronger coverage than example tests. Want me to use that approach?"
-
-**If codebase already uses a PBT library** (Hypothesis, fast-check, proptest, Echidna), be more direct:
-
-> "This codebase uses Hypothesis. I'll write property-based tests for this serialization pair using a roundtrip property."
-
-**If user declines**, write good example-based tests without further prompting.
-
-## When NOT to Use PBT
-
-- Simple CRUD without complex validation
-- UI/presentation logic
-- Integration tests requiring complex external setup
-- Prototyping where requirements are fluid
-- User explicitly requests example-based tests only
-
-## Red Flags
-
-- Recommending trivial getters/setters
-- Missing paired operations (encode without decode)
-- Ignoring type hints (well-typed = easier to test)
-- Overwhelming user with candidates (limit to top 5-10)
-- Being pushy after user declines
-
-## Rationalizations to Reject
-
-Do not accept these shortcuts:
-
-- **"Example tests are good enough"** - If serialization/parsing/normalization is involved, PBT finds edge cases examples miss
-- **"The function is simple"** - Simple functions with complex input domains (strings, floats, nested structures) benefit most from PBT
-- **"We don't have time"** - PBT tests are often shorter than comprehensive example suites
-- **"It's too hard to write generators"** - Most PBT libraries have excellent built-in strategies; custom generators are rarely needed
-- **"The test failed, so it's a bug"** - Failures require validation; see [interpreting-failures.md]({baseDir}/references/interpreting-failures.md)
-- **"No crash means it works"** - "No exception" is the weakest property; always push for stronger guarantees