codewave-openclaw-installer 1.0.2 → 2.1.1

package/skills/ppt-master/scripts/svg_quality_checker.py

@@ -0,0 +1,487 @@
+#!/usr/bin/env python3
+"""
+PPT Master - SVG Quality Check Tool
+
+Checks whether SVG files comply with project technical specifications.
+
+Usage:
+    python3 scripts/svg_quality_checker.py <svg_file>
+    python3 scripts/svg_quality_checker.py <directory>
+    python3 scripts/svg_quality_checker.py --all examples
+"""
+
+import sys
+import re
+from pathlib import Path
+from typing import List, Dict, Tuple
+from collections import defaultdict
+
+try:
+    from project_utils import CANVAS_FORMATS
+    from error_helper import ErrorHelper
+except ImportError:
+    print("Warning: Unable to import dependency modules")
+    CANVAS_FORMATS = {}
+    ErrorHelper = None
+
+
+class SVGQualityChecker:
+    """SVG quality checker"""
+
+    def __init__(self):
+        self.results = []
+        self.summary = {
+            'total': 0,
+            'passed': 0,
+            'warnings': 0,
+            'errors': 0
+        }
+        self.issue_types = defaultdict(int)
+
+    def check_file(self, svg_file: str, expected_format: str = None) -> Dict:
+        """
+        Check a single SVG file
+
+        Args:
+            svg_file: SVG file path
+            expected_format: Expected canvas format (e.g., 'ppt169')
+
+        Returns:
+            Check result dictionary
+        """
+        svg_path = Path(svg_file)
+
+        if not svg_path.exists():
+            return {
+                'file': str(svg_file),
+                'exists': False,
+                'errors': ['File does not exist'],
+                'warnings': [],
+                'passed': False
+            }
+
+        result = {
+            'file': svg_path.name,
+            'path': str(svg_path),
+            'exists': True,
+            'errors': [],
+            'warnings': [],
+            'info': {},
+            'passed': True
+        }
+
+        try:
+            with open(svg_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # 1. Check viewBox
+            self._check_viewbox(content, result, expected_format)
+
+            # 2. Check forbidden elements
+            self._check_forbidden_elements(content, result)
+
+            # 3. Check fonts
+            self._check_fonts(content, result)
+
+            # 4. Check width/height consistency with viewBox
+            self._check_dimensions(content, result)
+
+            # 5. Check text wrapping methods
+            self._check_text_elements(content, result)
+
+            # Determine pass/fail
+            result['passed'] = len(result['errors']) == 0
+
+        except Exception as e:
+            result['errors'].append(f"Failed to read file: {e}")
+            result['passed'] = False
+
+        # Update statistics
+        self.summary['total'] += 1
+        if result['passed']:
+            if result['warnings']:
+                self.summary['warnings'] += 1
+            else:
+                self.summary['passed'] += 1
+        else:
+            self.summary['errors'] += 1
+
+        # Categorize issue types
+        for error in result['errors']:
+            self.issue_types[self._categorize_issue(error)] += 1
+
+        self.results.append(result)
+        return result
+
+    def _check_viewbox(self, content: str, result: Dict, expected_format: str = None):
+        """Check viewBox attribute"""
+        viewbox_match = re.search(r'viewBox="([^"]+)"', content)
+
+        if not viewbox_match:
+            result['errors'].append("Missing viewBox attribute")
+            return
+
+        viewbox = viewbox_match.group(1)
+        result['info']['viewbox'] = viewbox
+
+        # Check format
+        if not re.match(r'0 0 \d+ \d+', viewbox):
+            result['warnings'].append(f"Unusual viewBox format: {viewbox}")
+
+        # Check if it matches expected format
+        if expected_format and expected_format in CANVAS_FORMATS:
+            expected_viewbox = CANVAS_FORMATS[expected_format]['viewbox']
+            if viewbox != expected_viewbox:
+                result['errors'].append(
+                    f"viewBox mismatch: expected '{expected_viewbox}', got '{viewbox}'"
+                )
+
+    def _check_forbidden_elements(self, content: str, result: Dict):
+        """Check forbidden elements (blocklist)"""
+        content_lower = content.lower()
+
+        # ============================================================
+        # Forbidden elements blocklist - PPT incompatible
+        # ============================================================
+
+        # Clipping / masking
+        if '<clippath' in content_lower:
+            result['errors'].append("Detected forbidden <clipPath> element (PPT does not support SVG clip paths)")
+        if '<mask' in content_lower:
+            result['errors'].append("Detected forbidden <mask> element (PPT does not support SVG masks)")
+
+        # Style system
+        if '<style' in content_lower:
+            result['errors'].append("Detected forbidden <style> element (use inline attributes instead)")
+        if re.search(r'\bclass\s*=', content):
+            result['errors'].append("Detected forbidden class attribute (use inline styles instead)")
+        # id attribute: only report error when <style> also exists (id is harmful only with CSS selectors)
+        # id inside <defs> for linearGradient/filter etc. is required, Inkscape also auto-adds id to elements,
+        # standalone id attributes have no impact on PPT export
+        if '<style' in content_lower and re.search(r'\bid\s*=', content):
+            result['errors'].append(
+                "Detected id attribute used with <style> (CSS selectors forbidden, use inline styles instead)"
+            )
+        if re.search(r'<\?xml-stylesheet\b', content_lower):
+            result['errors'].append("Detected forbidden xml-stylesheet (external CSS references forbidden)")
+        if re.search(r'<link[^>]*rel\s*=\s*["\']stylesheet["\']', content_lower):
+            result['errors'].append("Detected forbidden <link rel=\"stylesheet\"> (external CSS references forbidden)")
+        if re.search(r'@import\s+', content_lower):
+            result['errors'].append("Detected forbidden @import (external CSS references forbidden)")
+
+        # Structure / nesting
+        if '<foreignobject' in content_lower:
+            result['errors'].append(
+                "Detected forbidden <foreignObject> element (use <tspan> for manual line breaks)")
+        has_symbol = '<symbol' in content_lower
+        has_use = re.search(r'<use\b', content_lower) is not None
+        if has_symbol and has_use:
+            result['errors'].append("Detected forbidden <symbol> + <use> complex usage (use basic shapes or simple <use> instead)")
+        if '<marker' in content_lower:
+            result['errors'].append("Detected forbidden <marker> element (PPT does not support SVG markers)")
+        if re.search(r'\bmarker-end\s*=', content_lower):
+            result['errors'].append("Detected forbidden marker-end attribute (use line + polygon instead)")
+
+        # Text / fonts
+        if '<textpath' in content_lower:
+            result['errors'].append("Detected forbidden <textPath> element (path text is incompatible with PPT)")
+        if '@font-face' in content_lower:
+            result['errors'].append("Detected forbidden @font-face (use system font stack)")
+
+        # Animation / interaction
+        if re.search(r'<animate', content_lower):
+            result['errors'].append("Detected forbidden SMIL animation element <animate*> (SVG animations are not exported)")
+        if re.search(r'<set\b', content_lower):
+            result['errors'].append("Detected forbidden SMIL animation element <set> (SVG animations are not exported)")
+        if '<script' in content_lower:
+            result['errors'].append("Detected forbidden <script> element (scripts and event handlers forbidden)")
+        if re.search(r'\bon\w+\s*=', content):  # onclick, onload etc.
+            result['errors'].append("Detected forbidden event attributes (e.g., onclick, onload)")
+
+        # Other discouraged elements
+        if '<iframe' in content_lower:
+            result['errors'].append("Detected <iframe> element (should not appear in SVG)")
+        if re.search(r'rgba\s*\(', content_lower):
+            result['errors'].append("Detected forbidden rgba() color (use fill-opacity/stroke-opacity instead)")
+        if re.search(r'<g[^>]*\sopacity\s*=', content_lower):
+            result['errors'].append("Detected forbidden <g opacity> (set opacity on each child element individually)")
+        if re.search(r'<image[^>]*\sopacity\s*=', content_lower):
+            result['errors'].append("Detected forbidden <image opacity> (use overlay mask approach)")
+
+    def _check_fonts(self, content: str, result: Dict):
+        """Check font usage"""
+        # Find font-family declarations
+        font_matches = re.findall(
+            r'font-family[:\s]*["\']([^"\']+)["\']', content, re.IGNORECASE)
+
+        if font_matches:
+            result['info']['fonts'] = list(set(font_matches))
+
+            # Check if system UI font stack is used
+            recommended_fonts = [
+                'system-ui', '-apple-system', 'BlinkMacSystemFont', 'Segoe UI']
+
+            for font_family in font_matches:
+                has_recommended = any(
+                    rec in font_family for rec in recommended_fonts)
+
+                if not has_recommended:
+                    result['warnings'].append(
+                        f"Recommend using system UI font stack, current: {font_family}"
+                    )
+                    break  # Only warn once
+
+    def _check_dimensions(self, content: str, result: Dict):
+        """Check width/height consistency with viewBox"""
+        width_match = re.search(r'width="(\d+)"', content)
+        height_match = re.search(r'height="(\d+)"', content)
+
+        if width_match and height_match:
+            width = width_match.group(1)
+            height = height_match.group(1)
+            result['info']['dimensions'] = f"{width}x{height}"
+
+            # Check consistency with viewBox
+            if 'viewbox' in result['info']:
+                viewbox_parts = result['info']['viewbox'].split()
+                if len(viewbox_parts) == 4:
+                    vb_width, vb_height = viewbox_parts[2], viewbox_parts[3]
+                    if width != vb_width or height != vb_height:
+                        result['warnings'].append(
+                            f"width/height ({width}x{height}) does not match viewBox "
+                            f"({vb_width}x{vb_height})"
+                        )
+
+    def _check_text_elements(self, content: str, result: Dict):
+        """Check text elements and wrapping methods"""
+        # Count text and tspan elements
+        text_count = content.count('<text')
+        tspan_count = content.count('<tspan')
+
+        result['info']['text_elements'] = text_count
+        result['info']['tspan_elements'] = tspan_count
+
+        # Check for overly long single-line text (may need wrapping)
+        text_matches = re.findall(r'<text[^>]*>([^<]{100,})</text>', content)
+        if text_matches:
+            result['warnings'].append(
+                f"Detected {len(text_matches)} potentially overly long single-line text(s) (consider using tspan for wrapping)"
+            )
+
+    def _categorize_issue(self, error_msg: str) -> str:
+        """Categorize issue type"""
+        if 'viewBox' in error_msg:
+            return 'viewBox issues'
+        elif 'foreignObject' in error_msg:
+            return 'foreignObject'
+        elif 'font' in error_msg.lower():
+            return 'Font issues'
+        else:
+            return 'Other'
+
+    def check_directory(self, directory: str, expected_format: str = None) -> List[Dict]:
+        """
+        Check all SVG files in a directory
+
+        Args:
+            directory: Directory path
+            expected_format: Expected canvas format
+
+        Returns:
+            List of check results
+        """
+        dir_path = Path(directory)
+
+        if not dir_path.exists():
+            print(f"[ERROR] Directory does not exist: {directory}")
+            return []
+
+        # Find all SVG files
+        if dir_path.is_file():
+            svg_files = [dir_path]
+        else:
+            svg_output = dir_path / \
+                'svg_output' if (
+                    dir_path / 'svg_output').exists() else dir_path
+            svg_files = sorted(svg_output.glob('*.svg'))
+
+        if not svg_files:
+            print(f"[WARN] No SVG files found")
+            return []
+
+        print(f"\n[SCAN] Checking {len(svg_files)} SVG file(s)...\n")
+
+        for svg_file in svg_files:
+            result = self.check_file(str(svg_file), expected_format)
+            self._print_result(result)
+
+        return self.results
+
+    def _print_result(self, result: Dict):
+        """Print check result for a single file"""
+        if result['passed']:
+            if result['warnings']:
+                icon = "[WARN]"
+                status = "Passed (with warnings)"
+            else:
+                icon = "[OK]"
+                status = "Passed"
+        else:
+            icon = "[ERROR]"
+            status = "Failed"
+
+        print(f"{icon} {result['file']} - {status}")
+
+        # Display basic info
+        if result['info']:
+            info_items = []
+            if 'viewbox' in result['info']:
+                info_items.append(f"viewBox: {result['info']['viewbox']}")
+            if info_items:
+                print(f"   {' | '.join(info_items)}")
+
+        # Display errors
+        if result['errors']:
+            for error in result['errors']:
+                print(f"   [ERROR] {error}")
+
+        # Display warnings
+        if result['warnings']:
+            for warning in result['warnings'][:2]:  # Only show first 2 warnings
+                print(f"   [WARN] {warning}")
+            if len(result['warnings']) > 2:
+                print(f"   ... and {len(result['warnings']) - 2} more warning(s)")
+
+        print()
+
+    def print_summary(self):
+        """Print check summary"""
+        print("=" * 80)
+        print("[SUMMARY] Check Summary")
+        print("=" * 80)
+
+        print(f"\nTotal files: {self.summary['total']}")
+        print(
+            f"  [OK] Fully passed: {self.summary['passed']} ({self._percentage(self.summary['passed'])}%)")
+        print(
+            f"  [WARN] With warnings: {self.summary['warnings']} ({self._percentage(self.summary['warnings'])}%)")
+        print(
+            f"  [ERROR] With errors: {self.summary['errors']} ({self._percentage(self.summary['errors'])}%)")
+
+        if self.issue_types:
+            print(f"\nIssue categories:")
+            for issue_type, count in sorted(self.issue_types.items(), key=lambda x: x[1], reverse=True):
+                print(f"  {issue_type}: {count}")
+
+        # Fix suggestions
+        if self.summary['errors'] > 0 or self.summary['warnings'] > 0:
+            print(f"\n[TIP] Common fixes:")
+            print(f"  1. viewBox issues: Ensure consistency with canvas format (see references/canvas-formats.md)")
+            print(f"  2. foreignObject: Use <text> + <tspan> for manual line breaks")
+            print(f"  3. Font issues: Use system UI font stack")
+
+    def _percentage(self, count: int) -> int:
+        """Calculate percentage"""
+        if self.summary['total'] == 0:
+            return 0
+        return int(count / self.summary['total'] * 100)
+
+    def export_report(self, output_file: str = 'svg_quality_report.txt'):
+        """Export check report"""
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write("PPT Master SVG Quality Check Report\n")
+            f.write("=" * 80 + "\n\n")
+
+            for result in self.results:
+                status = "[OK] Passed" if result['passed'] else "[ERROR] Failed"
+                f.write(f"{status} - {result['file']}\n")
+                f.write(f"Path: {result.get('path', 'N/A')}\n")
+
+                if result['info']:
+                    f.write(f"Info: {result['info']}\n")
+
+                if result['errors']:
+                    f.write(f"\nErrors:\n")
+                    for error in result['errors']:
+                        f.write(f"  - {error}\n")
+
+                if result['warnings']:
+                    f.write(f"\nWarnings:\n")
+                    for warning in result['warnings']:
+                        f.write(f"  - {warning}\n")
+
+                f.write("\n" + "-" * 80 + "\n\n")
+
+            # Write summary
+            f.write("\n" + "=" * 80 + "\n")
+            f.write("Check Summary\n")
+            f.write("=" * 80 + "\n\n")
+            f.write(f"Total files: {self.summary['total']}\n")
+            f.write(f"Fully passed: {self.summary['passed']}\n")
+            f.write(f"With warnings: {self.summary['warnings']}\n")
+            f.write(f"With errors: {self.summary['errors']}\n")
+
+        print(f"\n[REPORT] Check report exported: {output_file}")
+
+
+def main() -> None:
+    """Run the CLI entry point."""
+    if len(sys.argv) < 2:
+        print("PPT Master - SVG Quality Check Tool\n")
+        print("Usage:")
+        print("  python3 scripts/svg_quality_checker.py <svg_file>")
+        print("  python3 scripts/svg_quality_checker.py <directory>")
+        print("  python3 scripts/svg_quality_checker.py --all examples")
+        print("\nExamples:")
+        print("  python3 scripts/svg_quality_checker.py examples/project/svg_output/slide_01.svg")
+        print("  python3 scripts/svg_quality_checker.py examples/project/svg_output")
+        print("  python3 scripts/svg_quality_checker.py examples/project")
+        sys.exit(0)
+
+    checker = SVGQualityChecker()
+
+    # Parse arguments
+    target = sys.argv[1]
+    expected_format = None
+
+    if '--format' in sys.argv:
+        idx = sys.argv.index('--format')
+        if idx + 1 < len(sys.argv):
+            expected_format = sys.argv[idx + 1]
+
+    # Execute check
+    if target == '--all':
+        # Check all example projects
+        base_dir = sys.argv[2] if len(sys.argv) > 2 else 'examples'
+        from project_utils import find_all_projects
+        projects = find_all_projects(base_dir)
+
+        for project in projects:
+            print(f"\n{'=' * 80}")
+            print(f"Checking project: {project.name}")
+            print('=' * 80)
+            checker.check_directory(str(project))
+    else:
+        checker.check_directory(target, expected_format)
+
+    # Print summary
+    checker.print_summary()
+
+    # Export report (if specified)
+    if '--export' in sys.argv:
+        output_file = 'svg_quality_report.txt'
+        if '--output' in sys.argv:
+            idx = sys.argv.index('--output')
+            if idx + 1 < len(sys.argv):
+                output_file = sys.argv[idx + 1]
+        checker.export_report(output_file)
+
+    # Return exit code
+    if checker.summary['errors'] > 0:
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

package/skills/ppt-master/scripts/svg_to_pptx/__init__.py

@@ -0,0 +1,17 @@
+"""svg_to_pptx — SVG to PPTX conversion package.
+
+Public API:
+    - main(): CLI entry point
+    - convert_svg_to_slide_shapes(): SVG -> DrawingML slide XML
+    - create_pptx_with_native_svg(): Build PPTX from SVG files
+"""
+
+from .pptx_cli import main
+from .drawingml_converter import convert_svg_to_slide_shapes
+from .pptx_builder import create_pptx_with_native_svg
+
+__all__ = [
+    'main',
+    'convert_svg_to_slide_shapes',
+    'create_pptx_with_native_svg',
+]

package/skills/ppt-master/scripts/svg_to_pptx/drawingml_context.py

@@ -0,0 +1,102 @@
+"""ConvertContext — shared state passed through the SVG → DrawingML pipeline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from xml.etree import ElementTree as ET
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ConvertContext:
+    """Shared context passed through the SVG → DrawingML conversion pipeline.
+
+    Derived via child() during recursive SVG tree traversal to accumulate
+    translate / scale / inherited style information.
+    """
+
+    defs: dict[str, ET.Element] = field(default_factory=dict)
+    id_counter: int = 2  # 1 is reserved for spTree root
+    slide_num: int = 1
+    translate_x: float = 0.0
+    translate_y: float = 0.0
+    scale_x: float = 1.0
+    scale_y: float = 1.0
+    filter_id: str | None = None
+    media_files: dict[str, bytes] = field(default_factory=dict)
+    rel_entries: list[dict[str, str]] = field(default_factory=list)
+    rel_id_counter: int = 2  # rId1 reserved for slideLayout
+    svg_dir: Path | None = None
+    inherited_styles: dict[str, str] = field(default_factory=dict)
+
+    def next_id(self) -> int:
+        """Allocate the next shape ID."""
+        cid = self.id_counter
+        self.id_counter += 1
+        return cid
+
+    def next_rel_id(self) -> str:
+        """Allocate the next relationship ID (rIdN)."""
+        rid = f'rId{self.rel_id_counter}'
+        self.rel_id_counter += 1
+        return rid
+
+    def child(
+        self,
+        dx: float = 0,
+        dy: float = 0,
+        sx: float = 1.0,
+        sy: float = 1.0,
+        filter_id: str | None = None,
+        style_overrides: dict[str, str] | None = None,
+    ) -> ConvertContext:
+        """Create a child context with accumulated translate / scale / styles.
+
+        Args:
+            dx: X translation delta.
+            dy: Y translation delta.
+            sx: X scale factor.
+            sy: Y scale factor.
+            filter_id: Override filter ID.
+            style_overrides: Style attribute overrides from child element.
+        """
+        merged = dict(self.inherited_styles)
+
+        if style_overrides:
+            # Opacity is multiplicative, not a simple override
+            _OPACITY_KEYS = ('opacity', 'fill-opacity', 'stroke-opacity')
+            for op_key in _OPACITY_KEYS:
+                if op_key in style_overrides and op_key in merged:
+                    try:
+                        merged[op_key] = str(
+                            float(merged[op_key]) * float(style_overrides[op_key])
+                        )
+                    except ValueError:
+                        merged[op_key] = style_overrides[op_key]
+                elif op_key in style_overrides:
+                    merged[op_key] = style_overrides[op_key]
+
+            for k, v in style_overrides.items():
+                if k not in _OPACITY_KEYS:
+                    merged[k] = v
+
+        return ConvertContext(
+            defs=self.defs,
+            id_counter=self.id_counter,
+            slide_num=self.slide_num,
+            translate_x=self.translate_x + dx,
+            translate_y=self.translate_y + dy,
+            scale_x=self.scale_x * sx,
+            scale_y=self.scale_y * sy,
+            filter_id=filter_id or self.filter_id,
+            media_files=self.media_files,
+            rel_entries=self.rel_entries,
+            rel_id_counter=self.rel_id_counter,
+            svg_dir=self.svg_dir,
+            inherited_styles=merged,
+        )
+
+    def sync_from_child(self, child_ctx: ConvertContext) -> None:
+        """Sync counters back from a child context."""
+        self.id_counter = child_ctx.id_counter
+        self.rel_id_counter = child_ctx.rel_id_counter