licos-dev-cli 0.3.7__tar.gz → 0.3.9__tar.gz

{licos_dev_cli-0.3.7 → licos_dev_cli-0.3.9}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: licos-dev-cli
-Version: 0.3.7
+Version: 0.3.9
 Summary: LICOS Dev CLI - generate files and call model capabilities
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1
-Requires-Dist: licos-dev-sdk>=0.3.7
+Requires-Dist: licos-dev-sdk>=0.3.9

{licos_dev_cli-0.3.7 → licos_dev_cli-0.3.9}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-cli"
-version = "0.3.7"
+version = "0.3.9"
 description = "LICOS Dev CLI - generate files and call model capabilities"
 requires-python = ">=3.10"
 dependencies = [
-    "licos-dev-sdk>=0.3.7",
+    "licos-dev-sdk>=0.3.9",
     "click>=8.1",
 ]
 

{licos_dev_cli-0.3.7 → licos_dev_cli-0.3.9}/src/licos_dev_cli/main.py

@@ -8,6 +8,8 @@ import os
 from pathlib import Path
 import click
 
+from .ppt_master import ppt_master
+
 # ── Helpers ──────────────────────────────────────────────────────────────────
 
 def _read_input(input_path: str | None, content: str | None) -> str:
@@ -95,6 +97,9 @@ def cli():
     pass
 
 
+cli.add_command(ppt_master)
+
+
 @cli.command("credit-check")
 @click.option("--estimated-points", default=1, type=click.IntRange(min=1), show_default=True)
 @click.option("--resource-type", default="MODEL_TOOL", show_default=True)
@@ -394,6 +399,51 @@ def pptx_deck(input_path, content, filename, output_dir, asset_base_path):
     _echo_path(path)
 
 
+@cli.command("pptx-native")
+@click.option(
+    "-i",
+    "--input",
+    "input_path",
+    required=True,
+    type=click.Path(exists=True, dir_okay=False),
+    help="Native canvas JSON specification file",
+)
+@click.option("-f", "--filename", required=True, help="Output filename without extension")
+@click.option("-o", "--output-dir", default=None, help="Output directory")
+@click.option(
+    "--asset-base-path",
+    default=None,
+    type=click.Path(file_okay=False),
+    help="Base directory for relative image paths; defaults to the JSON file directory",
+)
+def pptx_native(input_path, filename, output_dir, asset_base_path):
+    """Generate a free-form PPTX whose text, shapes, tables, and charts remain editable."""
+    from licos_dev_sdk import create_pptx_deck
+
+    spec = _read_json(input_path, None)
+    if not isinstance(spec, dict):
+        raise click.BadParameter("presentation specification must be a JSON object")
+    slides = spec.get("slides")
+    if not isinstance(slides, list) or not slides:
+        raise click.BadParameter("presentation specification must contain slides")
+    invalid = [
+        index
+        for index, slide in enumerate(slides)
+        if not isinstance(slide, dict)
+        or str(slide.get("type", "")).strip().lower() != "canvas"
+    ]
+    if invalid:
+        raise click.BadParameter(f"pptx-native requires type=canvas for every slide; invalid indexes: {invalid}")
+    base_path = asset_base_path or str(Path(input_path).resolve().parent)
+    path = create_pptx_deck(
+        spec,
+        filename,
+        output_dir=output_dir,
+        asset_base_path=base_path,
+    )
+    _echo_path(path)
+
+
 @cli.command("pptx-inspect")
 @click.option("-f", "--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
 @click.option("--min-slides", type=click.IntRange(min=1), default=None)

licos_dev_cli-0.3.9/src/licos_dev_cli/ppt_master.py

@@ -0,0 +1,586 @@
+"""Controlled CLI facade for the bundled PPT Master engine."""
+
+from __future__ import annotations
+
+import base64
+import json
+import mimetypes
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+import click
+
+
+UPSTREAM_REVISION = "ebd74d1f1d61a686f0f80e10abde5029fc4beeca"
+
+
+def _engine_home() -> Path:
+    from licos_dev_sdk import PptMasterRuntimeError, ensure_ppt_master_home
+
+    try:
+        return ensure_ppt_master_home()
+    except PptMasterRuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+def _run_script(script_name: str, arguments: list[str]) -> None:
+    root = _engine_home()
+    script = (root / "scripts" / script_name).resolve()
+    scripts_root = (root / "scripts").resolve()
+    if scripts_root not in script.parents or not script.is_file():
+        raise click.ClickException(f"Unsupported PPT Master script: {script_name}")
+
+    env = os.environ.copy()
+    env.setdefault("PYTHONUTF8", "1")
+    env.setdefault("PYTHONIOENCODING", "utf-8")
+    env["LICOS_PPT_MASTER_HOME"] = str(root)
+    completed = subprocess.run(
+        [sys.executable, str(script), *arguments],
+        env=env,
+        check=False,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if completed.stdout:
+        _echo_process_output(completed.stdout)
+    if completed.stderr:
+        _echo_process_output(completed.stderr, err=True)
+    if completed.returncode:
+        raise click.exceptions.Exit(completed.returncode)
+
+
+def _echo_process_output(value: str, *, err: bool = False) -> None:
+    stream = sys.stderr if err else sys.stdout
+    encoding = getattr(stream, "encoding", None) or "utf-8"
+    safe_value = value.encode(encoding, errors="backslashreplace").decode(encoding)
+    click.echo(safe_value, err=err, nl=not safe_value.endswith("\n"))
+
+
+def _option(arguments: list[str], name: str, value: object | None) -> None:
+    if value is not None:
+        arguments.extend([name, str(value)])
+
+
+def _flag(arguments: list[str], name: str, enabled: bool) -> None:
+    if enabled:
+        arguments.append(name)
+
+
+@click.group("ppt-master")
+def ppt_master() -> None:
+    """Use the bundled advanced PowerPoint workflow and native PPTX engine."""
+    if os.name == "nt":
+        for stream in (sys.stdout, sys.stderr):
+            reconfigure = getattr(stream, "reconfigure", None)
+            if callable(reconfigure):
+                reconfigure(encoding="utf-8", errors="backslashreplace")
+
+
+@ppt_master.command("info")
+def info() -> None:
+    """Show the installed engine revision and runtime capabilities."""
+    root = _engine_home()
+    payload = {
+        "engine": "ppt-master",
+        "revision": UPSTREAM_REVISION,
+        "home": str(root),
+        "routes": ["generate", "create-template", "fill-native", "enhance-native"],
+        "style_count": len(_load_catalog(root, "style")),
+        "deck_count": len(_load_catalog(root, "deck")),
+    }
+    click.echo(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def _load_catalog(root: Path, kind: str) -> dict[str, object]:
+    paths = {
+        "brand": root / "templates" / "brands" / "brands_index.json",
+        "style": root / "templates" / "styles" / "styles_index.json",
+        "layout": root / "templates" / "layouts" / "layouts_index.json",
+        "deck": root / "templates" / "decks" / "decks_index.json",
+    }
+    index_path = paths[kind]
+    if not index_path.is_file():
+        return {}
+    data = json.loads(index_path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise click.ClickException(f"Invalid {kind} catalog: {index_path}")
+    return data
+
+
+@ppt_master.command("catalog")
+@click.option("--kind", type=click.Choice(["brand", "style", "layout", "deck"]), default="style")
+def catalog(kind: str) -> None:
+    """List registered brand, style, layout, or deck workspaces."""
+    entries = _load_catalog(_engine_home(), kind)
+    click.echo(json.dumps({"kind": kind, "items": entries}, ensure_ascii=False, indent=2))
+
+
+def _template_workspace(root: Path, kind: str, template_id: str) -> Path:
+    directory = {
+        "brand": "brands",
+        "style": "styles",
+        "layout": "layouts",
+        "deck": "decks",
+    }[kind]
+    catalog_entries = _load_catalog(root, kind)
+    if template_id not in catalog_entries:
+        raise click.ClickException(f"Unknown registered {kind} template: {template_id}")
+    workspace = (root / "templates" / directory / template_id).resolve()
+    expected_parent = (root / "templates" / directory).resolve()
+    if expected_parent not in workspace.parents or not workspace.is_dir():
+        raise click.ClickException(f"Invalid registered {kind} workspace: {workspace}")
+    return workspace
+
+
+def _spec_with_provenance(source: Path, kind: str, template_id: str) -> str:
+    text = source.read_text(encoding="utf-8")
+    marker = f"> **Installed from**: bundled {kind} `{template_id}` ({UPSTREAM_REVISION[:8]})"
+    lines = text.splitlines()
+    heading_index = next((index for index, line in enumerate(lines) if line.startswith("# ")), None)
+    if heading_index is None:
+        return f"{marker}\n\n{text}"
+    lines[heading_index + 1 : heading_index + 1] = ["", marker]
+    return "\n".join(lines) + ("\n" if text.endswith("\n") else "")
+
+
+@ppt_master.command("install-template")
+@click.option("--kind", type=click.Choice(["brand", "style", "layout", "deck"]), required=True)
+@click.option("--id", "template_id", required=True)
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+def install_template(kind: str, template_id: str, project: str) -> None:
+    """Install one registered template workspace into a PPT project."""
+    root = _engine_home()
+    workspace = _template_workspace(root, kind, template_id)
+    source_templates = workspace / "templates"
+    source_spec = source_templates / "design_spec.md"
+    if not source_spec.is_file():
+        raise click.ClickException(f"Template workspace is missing design_spec.md: {workspace}")
+
+    _run_script("svg_quality_checker.py", [str(source_templates), "--template-mode"])
+
+    project_root = Path(project).resolve()
+    target_templates = project_root / "templates"
+    mappings: list[tuple[Path, Path]] = []
+    target_spec = target_templates / f"design_spec.{kind}.{template_id}.md"
+    if kind in {"layout", "deck"}:
+        mappings.extend(
+            (source, target_templates / source.relative_to(source_templates))
+            for source in source_templates.rglob("*")
+            if source.is_file() and source != source_spec
+        )
+    for asset_dir in ("images", "icons"):
+        source_assets = workspace / asset_dir
+        if source_assets.is_dir():
+            for source in source_assets.rglob("*"):
+                if not source.is_file():
+                    continue
+                relative = source.relative_to(source_assets)
+                mappings.append((source, project_root / asset_dir / relative))
+                if kind in {"layout", "deck"}:
+                    mappings.append((source, target_templates / asset_dir / relative))
+
+    destinations = [target_spec, *(destination for _, destination in mappings)]
+    collisions = [str(path) for path in destinations if path.exists()]
+    if collisions:
+        raise click.ClickException("Template install would overwrite existing files: " + ", ".join(collisions))
+
+    target_spec.parent.mkdir(parents=True, exist_ok=True)
+    target_spec.write_text(_spec_with_provenance(source_spec, kind, template_id), encoding="utf-8")
+    for source, destination in mappings:
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)
+
+    payload = {
+        "kind": kind,
+        "id": template_id,
+        "project": str(project_root),
+        "installed_spec": str(target_spec),
+        "installed_files": 1 + len(mappings),
+    }
+    click.echo(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+@ppt_master.command("init")
+@click.option("--name", required=True, help="ASCII-safe project name.")
+@click.option("--projects-root", required=True, type=click.Path(file_okay=False))
+@click.option("--format", "canvas_format", default=None, help="Registered canvas such as ppt169.")
+@click.option("--quick", is_flag=True, help="Create a lockless quick-generation workspace.")
+def init_project(name: str, projects_root: str, canvas_format: str | None, quick: bool) -> None:
+    """Initialize an advanced PPT project workspace."""
+    arguments = ["init", name, "--dir", projects_root]
+    _option(arguments, "--format", canvas_format)
+    _flag(arguments, "--quick-generate", quick)
+    _run_script("project_manager.py", arguments)
+
+
+@ppt_master.command("project-info")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+def project_info(project: str) -> None:
+    """Read advanced PPT project metadata."""
+    _run_script("project_manager.py", ["info", project])
+
+
+@ppt_master.command("import-sources")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+@click.option(
+    "--source",
+    "sources",
+    required=True,
+    multiple=True,
+    help="Source file, directory, or URL. Repeat for multiple sources.",
+)
+@click.option("--move/--copy", "move_sources", default=False)
+def import_sources(project: str, sources: tuple[str, ...], move_sources: bool) -> None:
+    """Import source material into an advanced PPT project."""
+    arguments = ["import-sources", project, *sources, "--move" if move_sources else "--copy"]
+    _run_script("project_manager.py", arguments)
+
+
+@ppt_master.command("scaffold-spec")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+def scaffold_spec(project: str) -> None:
+    """Create the versioned design specification scaffold."""
+    _run_script("project_manager.py", ["scaffold-spec", project])
+
+
+@ppt_master.command("scaffold-lock")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+def scaffold_lock(project: str) -> None:
+    """Create the versioned confirmed-design lock scaffold."""
+    _run_script("project_manager.py", ["scaffold-lock", project])
+
+
+@ppt_master.command("project-validate")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+def project_validate(project: str) -> None:
+    """Validate advanced PPT project structure and artifacts."""
+    _run_script("project_manager.py", ["validate", project])
+
+
+@ppt_master.command("quality")
+@click.option("--project", required=True, type=click.Path(exists=True))
+@click.option("--format", "canvas_format", default=None)
+@click.option("--stage", type=click.Choice(["first-page", "final"]), default="final")
+@click.option("--quick", is_flag=True)
+@click.option("--template-mode", is_flag=True)
+@click.option("--json-output", default=None, type=click.Path(dir_okay=False))
+def quality(
+    project: str,
+    canvas_format: str | None,
+    stage: str,
+    quick: bool,
+    template_mode: bool,
+    json_output: str | None,
+) -> None:
+    """Run PPT Master SVG and project quality checks."""
+    arguments = [project, "--stage", stage, "--json"]
+    _option(arguments, "--format", canvas_format)
+    _flag(arguments, "--quick-generate", quick)
+    _flag(arguments, "--template-mode", template_mode)
+    if json_output:
+        arguments.extend(["--json-output", json_output])
+    _run_script("svg_quality_checker.py", arguments)
+
+
+@ppt_master.command("export")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+@click.option("--output", required=True, type=click.Path(dir_okay=False))
+@click.option("--source", default=None, type=click.Path(exists=True, file_okay=False))
+@click.option("--format", "canvas_format", default=None)
+@click.option("--quick", is_flag=True)
+@click.option("--roundtrip", is_flag=True)
+@click.option("--native-charts-and-tables", is_flag=True)
+@click.option("--structure", type=click.Choice(["flat", "structured"]), default=None)
+@click.option("--transition", default=None)
+@click.option("--transition-duration", type=float, default=None)
+@click.option("--animation", default=None, help="PowerPoint animation preset.")
+@click.option("--animation-duration", type=float, default=None)
+@click.option("--with-notes/--no-notes", default=None)
+def export(
+    project: str,
+    output: str,
+    source: str | None,
+    canvas_format: str | None,
+    quick: bool,
+    roundtrip: bool,
+    native_charts_and_tables: bool,
+    structure: str | None,
+    transition: str | None,
+    transition_duration: float | None,
+    animation: str | None,
+    animation_duration: float | None,
+    with_notes: bool | None,
+) -> None:
+    """Export authored SVG pages to an editable native PPTX."""
+    arguments = [project, "--output", output]
+    _option(arguments, "--source", source)
+    _option(arguments, "--format", canvas_format)
+    _flag(arguments, "--quick-generate", quick)
+    _flag(arguments, "--roundtrip", roundtrip)
+    _flag(arguments, "--native-charts-and-tables", native_charts_and_tables)
+    _option(arguments, "--pptx-structure", structure)
+    _option(arguments, "--transition", transition)
+    _option(arguments, "--transition-duration", transition_duration)
+    _option(arguments, "--animation", animation)
+    _option(arguments, "--animation-duration", animation_duration)
+    if with_notes is not None:
+        arguments.append("--with-notes" if with_notes else "--no-notes")
+    _run_script("svg_to_pptx.py", arguments)
+
+
+@ppt_master.command("delivery-check")
+@click.option("--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
+def delivery_check(file_path: str) -> None:
+    """Inspect a finished PPTX for delivery risks without modifying it."""
+    _run_script("pptx_delivery_check.py", [file_path])
+
+
+@ppt_master.command("intake")
+@click.option("--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--output-dir", required=True, type=click.Path(file_okay=False))
+def intake(file_path: str, output_dir: str) -> None:
+    """Extract standard analysis artifacts from an existing PPTX."""
+    _run_script("pptx_intake.py", [file_path, "--output-dir", output_dir])
+
+
+@ppt_master.group("template")
+def template_group() -> None:
+    """Analyze and fill native PowerPoint templates."""
+
+
+@template_group.command("analyze")
+@click.option("--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--output", required=True, type=click.Path(dir_okay=False))
+def template_analyze(file_path: str, output: str) -> None:
+    _run_script("template_fill_pptx.py", ["analyze", file_path, "--output", output])
+
+
+@template_group.command("scaffold")
+@click.option("--library", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--output", required=True, type=click.Path(dir_okay=False))
+@click.option("--slides", default=None, help="Source slide list such as 1,3,5-7.")
+@click.option("--include-empty", is_flag=True)
+def template_scaffold(library: str, output: str, slides: str | None, include_empty: bool) -> None:
+    arguments = ["scaffold", library, "--output", output]
+    _option(arguments, "--slides", slides)
+    _flag(arguments, "--include-empty", include_empty)
+    _run_script("template_fill_pptx.py", arguments)
+
+
+@template_group.command("check-plan")
+@click.option("--library", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--plan", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--output", default=None, type=click.Path(dir_okay=False))
+def template_check_plan(library: str, plan: str, output: str | None) -> None:
+    arguments = ["check-plan", library, plan]
+    _option(arguments, "--output", output)
+    _run_script("template_fill_pptx.py", arguments)
+
+
+@template_group.command("apply")
+@click.option("--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--plan", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--output", required=True, type=click.Path(dir_okay=False))
+@click.option("--transition", default="keep")
+@click.option("--transition-duration", type=float, default=0.5)
+@click.option("--force", is_flag=True)
+def template_apply(
+    file_path: str,
+    plan: str,
+    output: str,
+    transition: str,
+    transition_duration: float,
+    force: bool,
+) -> None:
+    arguments = [
+        "apply",
+        file_path,
+        plan,
+        "--output",
+        output,
+        "--transition",
+        transition,
+        "--transition-duration",
+        str(transition_duration),
+    ]
+    _flag(arguments, "--force", force)
+    _run_script("template_fill_pptx.py", arguments)
+
+
+@template_group.command("validate")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+def template_validate(project: str) -> None:
+    _run_script("template_fill_pptx.py", ["validate", project])
+
+
+@template_group.command("preview")
+@click.option("--workspace", required=True, type=click.Path(exists=True, file_okay=False))
+@click.option("--output", default=None, type=click.Path(dir_okay=False))
+@click.option("--force", is_flag=True)
+@click.option("--visual-only", is_flag=True)
+def template_preview(
+    workspace: str,
+    output: str | None,
+    force: bool,
+    visual_only: bool,
+) -> None:
+    """Export a project-scoped template workspace as a review PPTX."""
+    workspace_root = Path(workspace).resolve()
+    output_path = str(Path(output).resolve()) if output else None
+    spec = workspace_root / "templates" / "design_spec.md"
+    if spec.is_file():
+        _run_template_preview(workspace_root, output_path, force, visual_only)
+        return
+
+    templates = workspace_root / "templates"
+    layout_specs = sorted(templates.glob("design_spec.layout.*.md"))
+    deck_specs = sorted(templates.glob("design_spec.deck.*.md"))
+    candidates = layout_specs or deck_specs
+    if len(candidates) != 1:
+        raise click.ClickException(
+            "Project-scoped template preview requires exactly one active layout or deck spec"
+        )
+
+    with tempfile.TemporaryDirectory(prefix="licos-ppt-template-preview-") as temporary:
+        preview_root = Path(temporary) / "workspace"
+        shutil.copytree(workspace_root, preview_root)
+        shutil.copy2(
+            preview_root / "templates" / candidates[0].name,
+            preview_root / "templates" / "design_spec.md",
+        )
+        for qualified_spec in (preview_root / "templates").glob("design_spec.*.*.md"):
+            qualified_spec.unlink()
+        _inline_local_preview_images(preview_root)
+        _run_template_preview(preview_root, output_path, force, visual_only)
+
+
+def _run_template_preview(
+    workspace: Path,
+    output: str | None,
+    force: bool,
+    visual_only: bool,
+) -> None:
+    arguments = [str(workspace)]
+    _option(arguments, "--output", output)
+    _flag(arguments, "--force", force)
+    _flag(arguments, "--visual-only", visual_only)
+    _run_script("template_preview_pptx.py", arguments)
+
+
+def _inline_local_preview_images(workspace: Path) -> None:
+    """Keep project-local images valid when upstream moves SVGs for review."""
+    svg_namespace = "http://www.w3.org/2000/svg"
+    xlink_namespace = "http://www.w3.org/1999/xlink"
+    ET.register_namespace("", svg_namespace)
+    ET.register_namespace("xlink", xlink_namespace)
+    workspace_root = workspace.resolve()
+    href_keys = ("href", f"{{{xlink_namespace}}}href")
+
+    for svg_path in sorted((workspace / "templates").glob("*.svg")):
+        tree = ET.parse(svg_path)
+        changed = False
+        for element in tree.getroot().iter():
+            if element.tag.rsplit("}", 1)[-1] != "image":
+                continue
+            href_key = next((key for key in href_keys if element.get(key)), None)
+            if href_key is None:
+                continue
+            href = (element.get(href_key) or "").strip()
+            if not href or href.startswith("data:") or href.startswith("#"):
+                continue
+            parsed = urlsplit(href)
+            if parsed.scheme not in {"", "file"}:
+                continue
+            decoded = unquote(parsed.path if parsed.scheme else href.split("?", 1)[0].split("#", 1)[0])
+            source = Path(decoded) if parsed.scheme == "file" else svg_path.parent / decoded
+            source = source.resolve()
+            try:
+                source.relative_to(workspace_root)
+            except ValueError as exc:
+                raise click.ClickException(
+                    f"Template image escapes its workspace: {href}"
+                ) from exc
+            if not source.is_file():
+                raise click.ClickException(f"Template image does not exist: {source}")
+            media_type = mimetypes.guess_type(source.name)[0] or "application/octet-stream"
+            encoded = base64.b64encode(source.read_bytes()).decode("ascii")
+            element.set(href_key, f"data:{media_type};base64,{encoded}")
+            changed = True
+        if changed:
+            tree.write(svg_path, encoding="utf-8", xml_declaration=True)
+
+
+@ppt_master.group("enhance")
+def enhance_group() -> None:
+    """Enhance an existing native PPTX without rebuilding visible slides."""
+
+
+def _enhance_motion(arguments: list[str], transition: str | None, duration: float | None) -> None:
+    _option(arguments, "--transition", transition)
+    _option(arguments, "--transition-duration", duration)
+
+
+@enhance_group.command("init")
+@click.option("--file", "file_path", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--project-dir", required=True, type=click.Path(file_okay=False))
+@click.option("--name", default=None)
+@click.option("--transition", default=None)
+@click.option("--transition-duration", type=float, default=None)
+def enhance_init(
+    file_path: str,
+    project_dir: str,
+    name: str | None,
+    transition: str | None,
+    transition_duration: float | None,
+) -> None:
+    arguments = ["init", file_path, "--project-dir", project_dir]
+    _option(arguments, "--name", name)
+    _enhance_motion(arguments, transition, transition_duration)
+    _run_script("native_enhance_pptx.py", arguments)
+
+
+@enhance_group.command("plan")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+@click.option("--transition", default=None)
+@click.option("--transition-duration", type=float, default=None)
+def enhance_plan(project: str, transition: str | None, transition_duration: float | None) -> None:
+    arguments = ["plan", project]
+    _enhance_motion(arguments, transition, transition_duration)
+    _run_script("native_enhance_pptx.py", arguments)
+
+
+@enhance_group.command("apply")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+@click.option("--output", required=True, type=click.Path(dir_okay=False))
+@click.option("--overwrite", is_flag=True)
+@click.option("--force", is_flag=True)
+@click.option("--transition", default=None)
+@click.option("--transition-duration", type=float, default=None)
+def enhance_apply(
+    project: str,
+    output: str,
+    overwrite: bool,
+    force: bool,
+    transition: str | None,
+    transition_duration: float | None,
+) -> None:
+    arguments = ["apply", project, "--output", output]
+    _flag(arguments, "--overwrite", overwrite)
+    _flag(arguments, "--force", force)
+    _enhance_motion(arguments, transition, transition_duration)
+    _run_script("native_enhance_pptx.py", arguments)
+
+
+@enhance_group.command("validate")
+@click.option("--project", required=True, type=click.Path(exists=True, file_okay=False))
+@click.option("--materials", type=click.Choice(["all", "notes"]), default="all")
+def enhance_validate(project: str, materials: str) -> None:
+    _run_script("native_enhance_pptx.py", ["validate", project, "--materials", materials])

licos_dev_cli-0.3.9/tests/test_ppt_master_cli.py

@@ -0,0 +1,125 @@
+import json
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from licos_dev_cli.main import cli
+from licos_dev_cli.ppt_master import _inline_local_preview_images
+
+
+def _fake_engine(tmp_path: Path) -> Path:
+    root = tmp_path / "ppt-master"
+    scripts = root / "scripts"
+    scripts.mkdir(parents=True)
+    (root / "templates" / "styles").mkdir(parents=True)
+    (root / "templates" / "decks").mkdir(parents=True)
+    (root / "workflows").mkdir()
+    (root / "LICENSE").write_text("MIT", encoding="utf-8")
+    (root / "templates" / "styles" / "styles_index.json").write_text(
+        json.dumps({"operating-review": {"summary": "Review"}}),
+        encoding="utf-8",
+    )
+    (root / "templates" / "decks" / "decks_index.json").write_text("{}", encoding="utf-8")
+    return root
+
+
+def test_ppt_master_info_reads_catalog(tmp_path: Path) -> None:
+    root = _fake_engine(tmp_path)
+    result = CliRunner().invoke(cli, ["ppt-master", "info"], env={"LICOS_PPT_MASTER_HOME": str(root)})
+
+    assert result.exit_code == 0, result.output
+    payload = json.loads(result.output)
+    assert payload["revision"].startswith("ebd74d1f")
+    assert payload["style_count"] == 1
+    assert payload["routes"] == ["generate", "create-template", "fill-native", "enhance-native"]
+
+
+def test_ppt_master_export_forwards_structured_arguments(tmp_path: Path) -> None:
+    root = _fake_engine(tmp_path)
+    project = tmp_path / "project"
+    project.mkdir()
+    output = tmp_path / "deck.pptx"
+    script = root / "scripts" / "svg_to_pptx.py"
+    script.write_text(
+        "import json, sys\nprint(json.dumps(sys.argv[1:]))\n",
+        encoding="utf-8",
+    )
+
+    result = CliRunner().invoke(
+        cli,
+        [
+            "ppt-master",
+            "export",
+            "--project",
+            str(project),
+            "--output",
+            str(output),
+            "--quick",
+            "--structure",
+            "flat",
+            "--transition",
+            "fade",
+        ],
+        env={"LICOS_PPT_MASTER_HOME": str(root)},
+    )
+
+    assert result.exit_code == 0, result.output
+    arguments = json.loads(result.output)
+    assert arguments[:2] == [str(project), "--output"]
+    assert str(output) in arguments
+    assert "--quick-generate" in arguments
+    assert arguments[arguments.index("--pptx-structure") + 1] == "flat"
+    assert arguments[arguments.index("--transition") + 1] == "fade"
+
+
+def test_ppt_master_quality_always_writes_machine_receipt(tmp_path: Path) -> None:
+    root = _fake_engine(tmp_path)
+    project = tmp_path / "project"
+    project.mkdir()
+    script = root / "scripts" / "svg_quality_checker.py"
+    script.write_text(
+        "import json, sys\nprint(json.dumps(sys.argv[1:]))\n",
+        encoding="utf-8",
+    )
+
+    result = CliRunner().invoke(
+        cli,
+        ["ppt-master", "quality", "--project", str(project), "--quick"],
+        env={"LICOS_PPT_MASTER_HOME": str(root)},
+    )
+
+    assert result.exit_code == 0, result.output
+    arguments = json.loads(result.output)
+    assert "--json" in arguments
+    assert "--quick-generate" in arguments
+
+
+def test_ppt_master_rejects_missing_runtime(tmp_path: Path) -> None:
+    result = CliRunner().invoke(
+        cli,
+        ["ppt-master", "info"],
+        env={"LICOS_PPT_MASTER_HOME": str(tmp_path / "missing")},
+    )
+
+    assert result.exit_code != 0
+    assert "runtime is incomplete" in result.output
+
+
+def test_template_preview_inlines_project_images(tmp_path: Path) -> None:
+    workspace = tmp_path / "workspace"
+    templates = workspace / "templates"
+    images = workspace / "images"
+    templates.mkdir(parents=True)
+    images.mkdir()
+    (images / "logo.png").write_bytes(b"\x89PNG\r\n\x1a\n")
+    svg = templates / "cover.svg"
+    svg.write_text(
+        '<svg xmlns="http://www.w3.org/2000/svg">'
+        '<image href="../images/logo.png" width="10" height="10"/>'
+        "</svg>",
+        encoding="utf-8",
+    )
+
+    _inline_local_preview_images(workspace)
+
+    assert "data:image/png;base64," in svg.read_text(encoding="utf-8")