@bcelep/capint 0.4.2 → 0.6.5

package/skills/pptx/scripts/check_env.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""Check pptx skill environment dependencies and report status."""
+
+import os
+import shutil
+import subprocess
+import sys
+import platform
+
+COMMON_BIN_PATHS = [
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    os.path.expanduser("~/.nvm/current/bin"),
+    os.path.expanduser("~/.local/bin"),
+]
+
+
+def _enrich_path():
+    """Add common install locations to PATH so we can find binaries
+    even when the shell session doesn't source .zshrc/.bashrc."""
+    current = os.environ.get("PATH", "")
+    dirs = current.split(os.pathsep)
+    added = []
+    for p in COMMON_BIN_PATHS:
+        if os.path.isdir(p) and p not in dirs:
+            dirs.insert(0, p)
+            added.append(p)
+    if added:
+        os.environ["PATH"] = os.pathsep.join(dirs)
+    return added
+
+
+def _find_binary(name):
+    """Find binary on PATH, and also scan common locations."""
+    found = shutil.which(name)
+    if found:
+        return found
+    for d in COMMON_BIN_PATHS:
+        candidate = os.path.join(d, name)
+        if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
+            return candidate
+    return None
+
+
+def check(name, cmd, hint):
+    binary = _find_binary(cmd[0]) if isinstance(cmd, list) else _find_binary(cmd)
+    if binary:
+        try:
+            run_cmd = [binary] + (cmd[1:] if isinstance(cmd, list) else ["--version"])
+            ver = subprocess.check_output(
+                run_cmd, stderr=subprocess.STDOUT, timeout=10
+            ).decode().strip().splitlines()[0]
+        except Exception:
+            ver = f"installed ({binary})"
+        return True, ver, binary
+    return False, hint, None
+
+
+def check_python_pkg(pkg, import_name=None):
+    import_name = import_name or pkg
+    try:
+        mod = __import__(import_name)
+        ver = getattr(mod, "__version__", "installed")
+        return True, ver
+    except ImportError:
+        return False, f"pip install {pkg}"
+
+
+def _run_install(cmd_str):
+    print(f"    Running: {cmd_str}")
+    try:
+        subprocess.check_call(cmd_str, shell=True, timeout=120)
+        print(f"    Done.")
+        return True
+    except Exception as e:
+        print(f"    Failed: {e}")
+        return False
+
+
+def main(install=False):
+    added_paths = _enrich_path()
+
+    print("=== pptx skill: Environment Check ===\n")
+    if added_paths:
+        print(f"  (Added to PATH: {', '.join(added_paths)})\n")
+
+    all_ok = True
+    missing_system = []
+    missing_py = []
+    missing_node = []
+
+    is_mac = platform.system() == "Darwin"
+    brew_path = _find_binary("brew")
+
+    checks = [
+        ("Python", ["python3", "--version"], "Install Python 3.8+"),
+        ("Node.js", ["node", "--version"], "brew install node" if is_mac else "https://nodejs.org"),
+        ("LibreOffice", ["soffice", "--version"], "brew install --cask libreoffice" if is_mac else "https://www.libreoffice.org"),
+        ("pdftoppm (Poppler)", ["pdftoppm", "-v"], "brew install poppler" if is_mac else "apt install poppler-utils"),
+    ]
+
+    print("[System Tools]")
+    for name, cmd, hint in checks:
+        ok, info, binary = check(name, cmd, hint)
+        symbol = "+" if ok else "-"
+        print(f"  [{symbol}] {name}: {info if ok else 'NOT FOUND -> ' + hint}")
+        if not ok:
+            all_ok = False
+            missing_system.append((name, hint))
+
+    py_pkgs = [
+        ("python-pptx", "pptx"),
+        ("Pillow", "PIL"),
+        ("defusedxml", "defusedxml"),
+        ("lxml", "lxml"),
+    ]
+
+    print("\n[Python Packages]")
+    for pkg, imp in py_pkgs:
+        ok, info = check_python_pkg(pkg, imp)
+        symbol = "+" if ok else "-"
+        print(f"  [{symbol}] {pkg}: {info if ok else 'NOT FOUND -> ' + info}")
+        if not ok:
+            all_ok = False
+            missing_py.append(pkg)
+
+    node_bin = _find_binary("node")
+    npm_bin = None
+    if node_bin:
+        node_dir = os.path.dirname(node_bin)
+        candidate_npm = os.path.join(node_dir, "npm")
+        if os.path.isfile(candidate_npm) and os.access(candidate_npm, os.X_OK):
+            npm_bin = candidate_npm
+    if not npm_bin:
+        npm_bin = _find_binary("npm")
+    node_pkgs = [("pptxgenjs", "pptxgenjs")]
+    global_node_path = None
+    if npm_bin:
+        try:
+            global_node_path = subprocess.check_output(
+                [npm_bin, "root", "-g"], stderr=subprocess.STDOUT, timeout=10
+            ).decode().strip()
+        except Exception:
+            pass
+
+    print("\n[Node Packages (scratch builds)]")
+    for pkg, _ in node_pkgs:
+        if node_bin:
+            env = os.environ.copy()
+            if global_node_path:
+                existing = env.get("NODE_PATH", "")
+                env["NODE_PATH"] = f"{global_node_path}:{existing}" if existing else global_node_path
+            try:
+                subprocess.check_output(
+                    [node_bin, "-e", f"require('{pkg}')"],
+                    stderr=subprocess.STDOUT, timeout=10, env=env
+                )
+                ok, info = True, "installed"
+            except Exception:
+                ok, info = False, f"npm install -g {pkg}"
+        else:
+            ok, info = False, "requires Node.js first"
+        symbol = "+" if ok else "-"
+        print(f"  [{symbol}] {pkg}: {info if ok else 'NOT FOUND -> ' + info}")
+        if not ok:
+            all_ok = False
+            missing_node.append(pkg)
+
+    print()
+    if all_ok:
+        print("All dependencies satisfied.")
+        return 0
+
+    if not install:
+        print("Some dependencies are missing. Install them with the commands above,")
+        print("or re-run with --install to auto-install missing items.")
+        return 1
+
+    print("--- Auto-installing missing dependencies ---\n")
+    if missing_py:
+        _run_install(f"pip3 install {' '.join(missing_py)}")
+
+    if missing_system and brew_path:
+        for name, hint in missing_system:
+            if hint.startswith("brew "):
+                _run_install(f"{brew_path} {hint[5:]}")
+    elif missing_system:
+        print("  [!] brew not found, cannot auto-install system tools.")
+        print("      Install Homebrew: https://brew.sh")
+
+    if missing_node and npm_bin:
+        for pkg in missing_node:
+            _run_install(f"{npm_bin} install -g {pkg}")
+    elif missing_node and _find_binary("npm"):
+        npm = _find_binary("npm")
+        for pkg in missing_node:
+            _run_install(f"{npm} install -g {pkg}")
+
+    print("\n--- Re-checking after install ---\n")
+    return main(install=False)
+
+
+if __name__ == "__main__":
+    do_install = "--install" in sys.argv
+    sys.exit(main(install=do_install))

package/skills/pptx/scripts/deck.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""Unified CLI for presentation file operations.
+
+Usage:
+    python deck.py check-env
+    python deck.py read      <pptx> [--format json] [--skip-notes] [--out FILE]
+    python deck.py thumbnails <pptx> [--columns N]
+    python deck.py unpack    <pptx> <workspace/>
+    python deck.py pack      <workspace/> <output.pptx> [--original FILE]
+    python deck.py render    <pptx> [--range PAGES] [--dpi N] [--dest DIR]
+    python deck.py clone     <workspace/> <source.xml>
+    python deck.py purge     <workspace/>
+    python deck.py create    <spec.json> <output.pptx>
+"""
+
+import argparse
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="deck.py", description="Presentation toolkit")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_read = sub.add_parser("read", help="Extract text content")
+    p_read.add_argument("pptx")
+    p_read.add_argument("--format", choices=["text", "json"], default="text")
+    p_read.add_argument("--skip-notes", action="store_true")
+    p_read.add_argument("--out", help="Write to file instead of stdout")
+
+    p_thumb = sub.add_parser("thumbnails", help="Generate slide thumbnail grid")
+    p_thumb.add_argument("pptx")
+    p_thumb.add_argument("--columns", type=int, default=3)
+
+    p_unpack = sub.add_parser("unpack", help="Extract and format PPTX for editing")
+    p_unpack.add_argument("pptx")
+    p_unpack.add_argument("workspace")
+
+    p_pack = sub.add_parser("pack", help="Reassemble workspace into PPTX")
+    p_pack.add_argument("workspace")
+    p_pack.add_argument("output")
+    p_pack.add_argument("--original", help="Source file for validation")
+    p_pack.add_argument("--skip-checks", action="store_true")
+
+    p_render = sub.add_parser("render", help="Render slides to images")
+    p_render.add_argument("pptx")
+    p_render.add_argument("--range", help="Page range e.g. '3-5'")
+    p_render.add_argument("--dpi", type=int, default=150)
+    p_render.add_argument("--dest", default=".")
+
+    p_clone = sub.add_parser("clone", help="Clone slide or create from layout")
+    p_clone.add_argument("workspace")
+    p_clone.add_argument("source", help="slide2.xml or slideLayout3.xml")
+
+    p_purge = sub.add_parser("purge", help="Remove orphaned files from workspace")
+    p_purge.add_argument("workspace")
+
+    p_create = sub.add_parser("create", help="Create deck from JSON spec")
+    p_create.add_argument("spec", help="JSON spec file path")
+    p_create.add_argument("output", help="Output PPTX path")
+
+    p_check = sub.add_parser("check-env", help="Check environment dependencies")
+    p_check.add_argument("--install", action="store_true", help="Auto-install missing deps")
+
+    args = parser.parse_args()
+
+    dispatch = {
+        "read": _cmd_read,
+        "thumbnails": _cmd_thumbnails,
+        "unpack": _cmd_unpack,
+        "pack": _cmd_pack,
+        "render": _cmd_render,
+        "clone": _cmd_clone,
+        "purge": _cmd_purge,
+        "create": _cmd_create,
+        "check-env": _cmd_check_env,
+    }
+    try:
+        dispatch[args.command](args)
+    except Exception as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+def _cmd_read(args):
+    from internals.content import extract_slides, format_plain, format_json
+
+    slides = extract_slides(args.pptx, notes=not args.skip_notes)
+    text = format_json(slides) if args.format == "json" else format_plain(slides)
+    if args.out:
+        from pathlib import Path
+        Path(args.out).write_text(text, encoding="utf-8")
+        print(f"Written to {args.out}")
+    else:
+        print(text)
+
+
+def _cmd_thumbnails(args):
+    from internals.gridshot import generate_grid
+    outputs = generate_grid(args.pptx, columns=args.columns)
+    for f in outputs:
+        print(f"Created: {f}")
+
+
+def _cmd_unpack(args):
+    from internals.packaging import disassemble
+    msg = disassemble(args.pptx, args.workspace)
+    print(msg)
+
+
+def _cmd_pack(args):
+    from internals.packaging import reassemble
+    msg = reassemble(
+        args.workspace, args.output,
+        reference=args.original,
+        validate=not args.skip_checks,
+    )
+    print(msg)
+
+
+def _cmd_render(args):
+    from internals.imaging import render_slides
+    images = render_slides(args.pptx, page_range=args.range, dpi=args.dpi, dest=args.dest)
+    print(f"Rendered {len(images)} slide(s):")
+    for img in images:
+        print(f"  {img}")
+
+
+def _cmd_clone(args):
+    from internals.structure import clone_or_instantiate
+    clone_or_instantiate(args.workspace, args.source)
+
+
+def _cmd_purge(args):
+    from internals.cleanup import sweep_workspace
+    removed = sweep_workspace(args.workspace)
+    if removed:
+        print(f"Removed {len(removed)} orphaned item(s):")
+        for r in removed:
+            print(f"  {r}")
+    else:
+        print("No orphans found")
+
+
+def _cmd_create(args):
+    from internals.create import create_deck
+    msg = create_deck(args.spec, args.output)
+    print(msg)
+
+
+def _cmd_check_env(args):
+    from pathlib import Path
+    import importlib.util
+    check_env_path = Path(__file__).parent / "check_env.py"
+    spec = importlib.util.spec_from_file_location("check_env", check_env_path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    sys.exit(mod.main(install=getattr(args, 'install', False)))
+
+
+if __name__ == "__main__":
+    main()

package/skills/pptx/scripts/internals/cleanup.py

@@ -0,0 +1,194 @@
+"""Orphaned file cleanup for unpacked PPTX workspaces."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import defusedxml.minidom
+
+
+def sweep_workspace(workspace: str) -> list[str]:
+    root = Path(workspace)
+    if not root.exists():
+        raise FileNotFoundError(f"{workspace} not found")
+
+    total_removed = []
+
+    total_removed.extend(_remove_stale_slides(root))
+    total_removed.extend(_remove_trash_dir(root))
+
+    while True:
+        batch = _remove_dangling_rels(root)
+        refs = _collect_all_references(root)
+        batch += _remove_unreferenced_files(root, refs)
+        if not batch:
+            break
+        total_removed.extend(batch)
+
+    if total_removed:
+        _clean_content_types(root, total_removed)
+
+    return total_removed
+
+
+def _active_slide_set(root: Path) -> set[str]:
+    pres = root / "ppt" / "presentation.xml"
+    rels = root / "ppt" / "_rels" / "presentation.xml.rels"
+    if not pres.exists() or not rels.exists():
+        return set()
+
+    dom = defusedxml.minidom.parse(str(rels))
+    rid_to_file = {}
+    for r in dom.getElementsByTagName("Relationship"):
+        t = r.getAttribute("Target")
+        if "slide" in r.getAttribute("Type") and t.startswith("slides/"):
+            rid_to_file[r.getAttribute("Id")] = t.rsplit("/", 1)[-1]
+
+    content = pres.read_text(encoding="utf-8")
+    live_rids = set(re.findall(r'<p:sldId[^>]*r:id="([^"]+)"', content))
+    return {rid_to_file[r] for r in live_rids if r in rid_to_file}
+
+
+def _remove_stale_slides(root: Path) -> list[str]:
+    slides_dir = root / "ppt" / "slides"
+    rels_dir = slides_dir / "_rels"
+    pres_rels = root / "ppt" / "_rels" / "presentation.xml.rels"
+
+    if not slides_dir.exists():
+        return []
+
+    live = _active_slide_set(root)
+    removed = []
+
+    for f in slides_dir.glob("slide*.xml"):
+        if f.name not in live:
+            rp = str(f.relative_to(root))
+            f.unlink()
+            removed.append(rp)
+            rf = rels_dir / f"{f.name}.rels"
+            if rf.exists():
+                rf.unlink()
+                removed.append(str(rf.relative_to(root)))
+
+    if removed and pres_rels.exists():
+        dom = defusedxml.minidom.parse(str(pres_rels))
+        changed = False
+        for r in list(dom.getElementsByTagName("Relationship")):
+            t = r.getAttribute("Target")
+            if t.startswith("slides/") and t.rsplit("/", 1)[-1] not in live:
+                r.parentNode.removeChild(r)
+                changed = True
+        if changed:
+            pres_rels.write_bytes(dom.toxml(encoding="utf-8"))
+
+    return removed
+
+
+def _remove_trash_dir(root: Path) -> list[str]:
+    trash = root / "[trash]"
+    removed = []
+    if trash.exists() and trash.is_dir():
+        for f in trash.iterdir():
+            if f.is_file():
+                removed.append(str(f.relative_to(root)))
+                f.unlink()
+        trash.rmdir()
+    return removed
+
+
+def _collect_all_references(root: Path) -> set:
+    refs = set()
+    for rf in root.rglob("*.rels"):
+        dom = defusedxml.minidom.parse(str(rf))
+        for r in dom.getElementsByTagName("Relationship"):
+            target = r.getAttribute("Target")
+            if not target:
+                continue
+            resolved = (rf.parent.parent / target).resolve()
+            try:
+                refs.add(resolved.relative_to(root.resolve()))
+            except ValueError:
+                pass
+    return refs
+
+
+def _slide_level_refs(root: Path) -> set:
+    refs = set()
+    rels_dir = root / "ppt" / "slides" / "_rels"
+    if not rels_dir.exists():
+        return refs
+    for rf in rels_dir.glob("*.rels"):
+        dom = defusedxml.minidom.parse(str(rf))
+        for r in dom.getElementsByTagName("Relationship"):
+            target = r.getAttribute("Target")
+            if not target:
+                continue
+            resolved = (rf.parent.parent / target).resolve()
+            try:
+                refs.add(resolved.relative_to(root.resolve()))
+            except ValueError:
+                pass
+    return refs
+
+
+def _remove_dangling_rels(root: Path) -> list[str]:
+    removed = []
+    sld_refs = _slide_level_refs(root)
+    for dirname in ("charts", "diagrams", "drawings"):
+        rdir = root / "ppt" / dirname / "_rels"
+        if not rdir.exists():
+            continue
+        for rf in rdir.glob("*.rels"):
+            resource = rdir.parent / rf.name.replace(".rels", "")
+            try:
+                rel_path = resource.resolve().relative_to(root.resolve())
+            except ValueError:
+                continue
+            if not resource.exists() or rel_path not in sld_refs:
+                rf.unlink()
+                removed.append(str(rf.relative_to(root)))
+    return removed
+
+
+def _remove_unreferenced_files(root: Path, referenced: set) -> list[str]:
+    removed = []
+
+    for dirname in ("media", "embeddings", "charts", "diagrams", "tags", "drawings", "ink"):
+        d = root / "ppt" / dirname
+        if not d.exists():
+            continue
+        for f in d.glob("*"):
+            if f.is_file() and f.relative_to(root) not in referenced:
+                f.unlink()
+                removed.append(str(f.relative_to(root)))
+
+    notes_dir = root / "ppt" / "notesSlides"
+    if notes_dir.exists():
+        for f in notes_dir.glob("*.xml"):
+            if f.is_file() and f.relative_to(root) not in referenced:
+                f.unlink()
+                removed.append(str(f.relative_to(root)))
+        nrels = notes_dir / "_rels"
+        if nrels.exists():
+            for rf in nrels.glob("*.rels"):
+                nf = notes_dir / rf.name.replace(".rels", "")
+                if not nf.exists():
+                    rf.unlink()
+                    removed.append(str(rf.relative_to(root)))
+
+    return removed
+
+
+def _clean_content_types(root: Path, removed: list[str]) -> None:
+    ct = root / "[Content_Types].xml"
+    if not ct.exists():
+        return
+    dom = defusedxml.minidom.parse(str(ct))
+    changed = False
+    for ov in list(dom.getElementsByTagName("Override")):
+        pn = ov.getAttribute("PartName").lstrip("/")
+        if pn in removed:
+            ov.parentNode.removeChild(ov)
+            changed = True
+    if changed:
+        ct.write_bytes(dom.toxml(encoding="utf-8"))

package/skills/pptx/scripts/internals/content.py

@@ -0,0 +1,62 @@
+"""Text and metadata extraction from PPTX files."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from pptx import Presentation
+
+
+def extract_slides(pptx_path: str, notes: bool = True) -> list[dict]:
+    prs = Presentation(pptx_path)
+    result = []
+
+    for idx, slide in enumerate(prs.slides, 1):
+        record = {"number": idx, "heading": "", "content": [], "notes": ""}
+
+        for shape in slide.shapes:
+            if not shape.has_text_frame:
+                continue
+            raw_parts = []
+            for p in shape.text_frame.paragraphs:
+                ptext = p.text.replace("\x0b", "\n")
+                if not ptext.strip():
+                    continue
+                raw_parts.append(ptext)
+            block = "\n".join(raw_parts)
+            if not block:
+                continue
+            if shape == slide.shapes.title:
+                record["heading"] = block
+            else:
+                record["content"].append(block)
+
+        if notes and slide.has_notes_slide:
+            tf = slide.notes_slide.notes_text_frame
+            if tf:
+                record["notes"] = tf.text
+
+        result.append(record)
+
+    return result
+
+
+def format_plain(slides: list[dict]) -> str:
+    sections = []
+    for s in slides:
+        header = f"=== Slide {s['number']} ==="
+        parts = [header]
+        if s["heading"]:
+            for line in s["heading"].split("\n"):
+                parts.append(f"  {line}")
+        for block in s["content"]:
+            for line in block.split("\n"):
+                parts.append(f"  {line}")
+        if s["notes"]:
+            parts.append(f"  [Speaker Notes] {s['notes']}")
+        sections.append("\n".join(parts))
+    return "\n\n".join(sections)
+
+
+def format_json(slides: list[dict]) -> str:
+    return json.dumps(slides, indent=2, ensure_ascii=False)