licos-dev-sdk 0.1.0__tar.gz

licos_dev_sdk-0.1.0/.gitignore

@@ -0,0 +1,44 @@
+# Rust
+/target/
+**/*.rs.bk
+Cargo.lock
+
+# Node
+node_modules/
+packages/*/dist/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Workspace
+/workspace/
+
+# Test runtime data
+/test/licos-data/
+/test/screenshots/
+/test/vue-app/
+
+# Build
+*.log
+.licos
+
+/tmp
+
+/Docs/hermes-agent
+/Docs/OpenCode
+/Docs/平台API
+
+*.codex-*
+
+project-20260423_130440

licos_dev_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: licos-dev-sdk
+Version: 0.1.0
+Summary: LICOS file generation SDK — PDF, DOCX, XLSX, PPTX, charts, diagrams, QR codes, and more
+Requires-Python: >=3.10
+Requires-Dist: graphviz>=0.20
+Requires-Dist: jinja2>=3.1
+Requires-Dist: matplotlib>=3.9
+Requires-Dist: mistune>=3.0
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pillow>=10.0
+Requires-Dist: python-barcode>=0.15
+Requires-Dist: python-docx>=1.1
+Requires-Dist: python-pptx>=1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: qrcode[pil]>=8.0
+Requires-Dist: weasyprint>=62.0

licos_dev_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "licos-dev-sdk"
+version = "0.1.0"
+description = "LICOS file generation SDK — PDF, DOCX, XLSX, PPTX, charts, diagrams, QR codes, and more"
+requires-python = ">=3.10"
+dependencies = [
+    "weasyprint>=62.0",
+    "python-docx>=1.1",
+    "openpyxl>=3.1",
+    "python-pptx>=1.0",
+    "matplotlib>=3.9",
+    "graphviz>=0.20",
+    "qrcode[pil]>=8.0",
+    "python-barcode>=0.15",
+    "Pillow>=10.0",
+    "Jinja2>=3.1",
+    "mistune>=3.0",
+    "PyYAML>=6.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/licos_dev_sdk"]

licos_dev_sdk-0.1.0/src/licos_dev_sdk/__init__.py

@@ -0,0 +1,57 @@
+"""LICOS Dev SDK — file generation toolkit.
+
+Modules with heavy native dependencies (weasyprint, graphviz, matplotlib)
+are lazy-imported to avoid errors in minimal environments (e.g., node-base).
+"""
+
+
+def __getattr__(name: str):
+    """Lazy import — only load modules when accessed."""
+    _map = {
+        # data
+        "create_json": ("data", "create_json"),
+        "create_xml": ("data", "create_xml"),
+        "create_yaml": ("data", "create_yaml"),
+        # archive
+        "create_zip": ("archive", "create_zip"),
+        "create_tar_gz": ("archive", "create_tar_gz"),
+        # image
+        "create_qrcode": ("image", "create_qrcode"),
+        "create_barcode": ("image", "create_barcode"),
+        "create_watermark": ("image", "create_watermark"),
+        # web
+        "create_html": ("web", "create_html"),
+        "create_markdown": ("web", "create_markdown"),
+        "markdown_to_html": ("web", "markdown_to_html"),
+        # document
+        "create_pdf": ("document", "create_pdf"),
+        "create_docx": ("document", "create_docx"),
+        # spreadsheet
+        "create_xlsx": ("spreadsheet", "create_xlsx"),
+        "create_csv": ("spreadsheet", "create_csv"),
+        # chart
+        "create_chart": ("chart", "create_chart"),
+        # diagram
+        "create_diagram": ("diagram", "create_diagram"),
+        # presentation
+        "create_pptx": ("presentation", "create_pptx"),
+    }
+    if name in _map:
+        mod_name, attr = _map[name]
+        import importlib
+        mod = importlib.import_module(f".{mod_name}", __name__)
+        return getattr(mod, attr)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "create_json", "create_xml", "create_yaml",
+    "create_zip", "create_tar_gz",
+    "create_qrcode", "create_barcode", "create_watermark",
+    "create_html", "create_markdown", "markdown_to_html",
+    "create_pdf", "create_docx",
+    "create_xlsx", "create_csv",
+    "create_chart",
+    "create_diagram",
+    "create_pptx",
+]

licos_dev_sdk-0.1.0/src/licos_dev_sdk/_utils.py

@@ -0,0 +1,34 @@
+"""Shared utilities for output path resolution and file naming."""
+
+from __future__ import annotations
+
+import os
+from datetime import datetime
+from pathlib import Path
+
+
+def resolve_output_dir(output_dir: str | None = None) -> Path:
+    """Resolve the output directory.
+
+    Priority: explicit arg > $LICOS_WORKSPACE_PATH > cwd
+    """
+    if output_dir:
+        p = Path(output_dir)
+    else:
+        env = os.environ.get("LICOS_WORKSPACE_PATH", "")
+        p = Path(env) if env else Path.cwd()
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def resolve_output_path(filename: str, ext: str, output_dir: str | None = None) -> Path:
+    """Build the full output path, auto-adding extension and deduplicating."""
+    d = resolve_output_dir(output_dir)
+    # Ensure ext starts with dot
+    if not ext.startswith("."):
+        ext = f".{ext}"
+    path = d / f"{filename}{ext}"
+    if path.exists():
+        ts = datetime.now().strftime("%Y%m%d%H%M%S")
+        path = d / f"{filename}_{ts}{ext}"
+    return path

licos_dev_sdk-0.1.0/src/licos_dev_sdk/archive.py

@@ -0,0 +1,34 @@
+"""Archive generation — ZIP, TAR.GZ."""
+
+from __future__ import annotations
+
+import tarfile
+import zipfile
+from pathlib import Path
+
+from ._utils import resolve_output_path
+
+
+def create_zip(source_paths: list[str], filename: str, *, output_dir: str | None = None) -> str:
+    """Create a ZIP archive from a list of files/directories. Returns absolute path."""
+    path = resolve_output_path(filename, ".zip", output_dir)
+    with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for src in source_paths:
+            p = Path(src)
+            if p.is_dir():
+                for child in p.rglob("*"):
+                    if child.is_file():
+                        zf.write(child, child.relative_to(p.parent))
+            elif p.is_file():
+                zf.write(p, p.name)
+    return str(path.resolve())
+
+
+def create_tar_gz(source_paths: list[str], filename: str, *, output_dir: str | None = None) -> str:
+    """Create a TAR.GZ archive from a list of files/directories. Returns absolute path."""
+    path = resolve_output_path(filename, ".tar.gz", output_dir)
+    with tarfile.open(path, "w:gz") as tf:
+        for src in source_paths:
+            p = Path(src)
+            tf.add(p, arcname=p.name)
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/chart.py

@@ -0,0 +1,80 @@
+"""Chart generation — bar, line, pie, scatter, heatmap via matplotlib."""
+
+from __future__ import annotations
+
+import matplotlib
+matplotlib.use("Agg")  # Non-interactive backend
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ._utils import resolve_output_path
+
+
+def create_chart(chart_type: str, data: dict, filename: str, *,
+                 output_dir: str | None = None, format: str = "png",
+                 title: str = "", width: int = 800, height: int = 600) -> str:
+    """Generate a chart image (PNG/SVG). Returns absolute path.
+
+    Args:
+        chart_type: "bar" | "line" | "pie" | "scatter" | "heatmap"
+        data: {
+            "labels": ["A", "B", "C"],
+            "datasets": [{"label": "Series 1", "values": [10, 20, 30]}]
+        }
+        For pie: only first dataset is used.
+        For heatmap: data["matrix"] = [[1,2],[3,4]], data["x_labels"], data["y_labels"]
+    """
+    path = resolve_output_path(filename, f".{format}", output_dir)
+    dpi = 100
+    fig, ax = plt.subplots(figsize=(width / dpi, height / dpi), dpi=dpi)
+
+    labels = data.get("labels", [])
+    datasets = data.get("datasets", [])
+
+    if chart_type == "bar":
+        x = np.arange(len(labels))
+        n = len(datasets)
+        bar_width = 0.8 / max(n, 1)
+        for i, ds in enumerate(datasets):
+            offset = (i - n / 2 + 0.5) * bar_width
+            ax.bar(x + offset, ds["values"], bar_width, label=ds.get("label", ""))
+        ax.set_xticks(x)
+        ax.set_xticklabels(labels)
+        if n > 1:
+            ax.legend()
+
+    elif chart_type == "line":
+        for ds in datasets:
+            ax.plot(labels, ds["values"], marker="o", label=ds.get("label", ""))
+        if len(datasets) > 1:
+            ax.legend()
+
+    elif chart_type == "pie":
+        values = datasets[0]["values"] if datasets else []
+        ax.pie(values, labels=labels, autopct="%1.1f%%", startangle=90)
+        ax.axis("equal")
+
+    elif chart_type == "scatter":
+        for ds in datasets:
+            x_vals = ds.get("x", list(range(len(ds["values"]))))
+            ax.scatter(x_vals, ds["values"], label=ds.get("label", ""), alpha=0.7)
+        if len(datasets) > 1:
+            ax.legend()
+
+    elif chart_type == "heatmap":
+        matrix = np.array(data.get("matrix", [[]]))
+        im = ax.imshow(matrix, cmap="YlOrRd", aspect="auto")
+        fig.colorbar(im, ax=ax)
+        if "x_labels" in data:
+            ax.set_xticks(range(len(data["x_labels"])))
+            ax.set_xticklabels(data["x_labels"])
+        if "y_labels" in data:
+            ax.set_yticks(range(len(data["y_labels"])))
+            ax.set_yticklabels(data["y_labels"])
+
+    if title:
+        ax.set_title(title)
+    fig.tight_layout()
+    fig.savefig(str(path), format=format, bbox_inches="tight")
+    plt.close(fig)
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/data.py

@@ -0,0 +1,56 @@
+"""Data file generation — JSON, XML, YAML."""
+
+from __future__ import annotations
+
+import json
+import csv as csv_mod
+import io
+from typing import Any
+from xml.etree.ElementTree import Element, SubElement, tostring
+from xml.dom.minidom import parseString
+
+import yaml
+
+from ._utils import resolve_output_path
+
+
+def create_json(data: Any, filename: str, *, output_dir: str | None = None, indent: int = 2) -> str:
+    """Write data as a formatted JSON file. Returns absolute path."""
+    path = resolve_output_path(filename, ".json", output_dir)
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=indent), encoding="utf-8")
+    return str(path.resolve())
+
+
+def create_yaml(data: Any, filename: str, *, output_dir: str | None = None) -> str:
+    """Write data as a YAML file. Returns absolute path."""
+    path = resolve_output_path(filename, ".yaml", output_dir)
+    path.write_text(yaml.dump(data, allow_unicode=True, default_flow_style=False, sort_keys=False), encoding="utf-8")
+    return str(path.resolve())
+
+
+def create_xml(data: dict, filename: str, *, output_dir: str | None = None, root_tag: str = "root") -> str:
+    """Write a dict as an XML file. Returns absolute path."""
+    path = resolve_output_path(filename, ".xml", output_dir)
+
+    def _dict_to_xml(parent: Element, d: dict | list | Any) -> None:
+        if isinstance(d, dict):
+            for key, val in d.items():
+                child = SubElement(parent, str(key))
+                _dict_to_xml(child, val)
+        elif isinstance(d, list):
+            for item in d:
+                child = SubElement(parent, "item")
+                _dict_to_xml(child, item)
+        else:
+            parent.text = str(d)
+
+    root = Element(root_tag)
+    _dict_to_xml(root, data)
+    raw = tostring(root, encoding="unicode")
+    pretty = parseString(raw).toprettyxml(indent="  ")
+    # Remove extra xml declaration line
+    lines = pretty.split("\n")
+    if lines and lines[0].startswith("<?xml"):
+        lines[0] = '<?xml version="1.0" encoding="UTF-8"?>'
+    path.write_text("\n".join(lines), encoding="utf-8")
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/diagram.py

@@ -0,0 +1,22 @@
+"""Diagram generation — Graphviz DOT → PNG/SVG."""
+
+from __future__ import annotations
+
+import graphviz
+
+from ._utils import resolve_output_path
+
+
+def create_diagram(dot_source: str, filename: str, *,
+                   output_dir: str | None = None, format: str = "png") -> str:
+    """Render a Graphviz DOT source to an image. Returns absolute path.
+
+    Args:
+        dot_source: DOT language string (e.g., 'digraph { A -> B }')
+        format: "png" | "svg" | "pdf"
+    """
+    path = resolve_output_path(filename, f".{format}", output_dir)
+    src = graphviz.Source(dot_source)
+    # graphviz renders to {filename}.{format} — render to parent dir with stem
+    rendered = src.render(filename=str(path.with_suffix("")), format=format, cleanup=True)
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/document.py

@@ -0,0 +1,98 @@
+"""Document generation — PDF, DOCX."""
+
+from __future__ import annotations
+
+import mistune
+from weasyprint import HTML
+from docx import Document
+from docx.shared import Pt, Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+from ._utils import resolve_output_path
+
+_PDF_CSS = """
+@page { size: {page_size}; margin: 2cm; }
+body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Noto Sans CJK SC", sans-serif;
+       font-size: 11pt; line-height: 1.6; color: #333; }
+h1 { font-size: 22pt; margin-top: 0; }
+h2 { font-size: 16pt; }
+h3 { font-size: 13pt; }
+table { border-collapse: collapse; width: 100%; margin: 1em 0; }
+th, td { border: 1px solid #ccc; padding: 6px 10px; text-align: left; }
+th { background: #f0f0f0; font-weight: 600; }
+code { background: #f4f4f4; padding: 1px 4px; border-radius: 3px; font-size: 10pt; }
+pre { background: #f4f4f4; padding: 12px; border-radius: 4px; overflow-x: auto; }
+blockquote { border-left: 3px solid #ccc; margin-left: 0; padding-left: 1em; color: #666; }
+"""
+
+
+def create_pdf(content: str, filename: str, *, content_type: str = "markdown",
+               output_dir: str | None = None, page_size: str = "A4") -> str:
+    """Generate a PDF file from Markdown or HTML. Returns absolute path."""
+    path = resolve_output_path(filename, ".pdf", output_dir)
+    html_body = mistune.html(content) if content_type == "markdown" else content
+    css = _PDF_CSS.replace("{page_size}", page_size)
+    full_html = f"<html><head><style>{css}</style></head><body>{html_body}</body></html>"
+    HTML(string=full_html).write_pdf(str(path))
+    return str(path.resolve())
+
+
+def create_docx(content: str, filename: str, *, content_type: str = "markdown",
+                output_dir: str | None = None, font_name: str = "Arial", font_size: int = 11) -> str:
+    """Generate a DOCX file from Markdown or HTML. Returns absolute path.
+
+    Converts Markdown to a simple DOCX with headings, paragraphs, and lists.
+    For complex HTML, consider generating PDF instead.
+    """
+    path = resolve_output_path(filename, ".docx", output_dir)
+
+    if content_type == "html":
+        # For HTML input, convert to markdown-like text first
+        import re
+        text = re.sub(r"<[^>]+>", "", content)
+        lines = [l.strip() for l in text.split("\n") if l.strip()]
+    else:
+        lines = content.split("\n")
+
+    doc = Document()
+    # Set default font
+    style = doc.styles["Normal"]
+    style.font.name = font_name
+    style.font.size = Pt(font_size)
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        # Headings
+        if stripped.startswith("######"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=6)
+        elif stripped.startswith("#####"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=5)
+        elif stripped.startswith("####"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=4)
+        elif stripped.startswith("###"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=3)
+        elif stripped.startswith("##"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=2)
+        elif stripped.startswith("#"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=1)
+        # Unordered list
+        elif stripped.startswith("- ") or stripped.startswith("* "):
+            doc.add_paragraph(stripped[2:], style="List Bullet")
+        # Ordered list
+        elif len(stripped) > 2 and stripped[0].isdigit() and stripped[1] in (".", ")"):
+            doc.add_paragraph(stripped[2:].strip(), style="List Number")
+        # Blockquote
+        elif stripped.startswith("> "):
+            p = doc.add_paragraph(stripped[2:])
+            p.paragraph_format.left_indent = Inches(0.5)
+            p.style.font.italic = True
+        # Horizontal rule
+        elif stripped in ("---", "***", "___"):
+            doc.add_paragraph("─" * 50)
+        else:
+            doc.add_paragraph(stripped)
+
+    doc.save(str(path))
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/image.py

@@ -0,0 +1,60 @@
+"""Image generation — QR code, barcode, watermark."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import qrcode
+import barcode as barcode_lib
+from barcode.writer import ImageWriter
+from PIL import Image, ImageDraw, ImageFont
+
+from ._utils import resolve_output_path
+
+
+def create_qrcode(data: str, filename: str, *, output_dir: str | None = None, size: int = 300) -> str:
+    """Generate a QR code PNG image. Returns absolute path."""
+    path = resolve_output_path(filename, ".png", output_dir)
+    qr = qrcode.QRCode(box_size=10, border=2)
+    qr.add_data(data)
+    qr.make(fit=True)
+    img = qr.make_image(fill_color="black", back_color="white")
+    img = img.resize((size, size))
+    img.save(str(path))
+    return str(path.resolve())
+
+
+def create_barcode(data: str, filename: str, *, output_dir: str | None = None, barcode_type: str = "code128") -> str:
+    """Generate a barcode PNG image. Returns absolute path."""
+    path = resolve_output_path(filename, ".png", output_dir)
+    bc_class = barcode_lib.get_barcode_class(barcode_type)
+    bc = bc_class(data, writer=ImageWriter())
+    # python-barcode appends extension, save without it
+    saved = bc.save(str(path.with_suffix("")))
+    return str(Path(saved).resolve())
+
+
+def create_watermark(text: str, filename: str, *, output_dir: str | None = None,
+                     width: int = 800, height: int = 600, opacity: float = 0.3) -> str:
+    """Generate a semi-transparent watermark PNG image. Returns absolute path."""
+    path = resolve_output_path(filename, ".png", output_dir)
+    img = Image.new("RGBA", (width, height), (255, 255, 255, 0))
+    draw = ImageDraw.Draw(img)
+
+    # Use default font, scale size to image
+    font_size = max(width, height) // 10
+    try:
+        font = ImageFont.truetype("arial.ttf", font_size)
+    except (OSError, IOError):
+        font = ImageFont.load_default()
+
+    alpha = int(255 * opacity)
+    fill = (128, 128, 128, alpha)
+
+    # Tile the watermark text diagonally
+    for y in range(-height, height * 2, font_size * 3):
+        for x in range(-width, width * 2, font_size * len(text)):
+            draw.text((x, y), text, fill=fill, font=font)
+
+    img.save(str(path), "PNG")
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/presentation.py

@@ -0,0 +1,103 @@
+"""Presentation generation — PPTX from Markdown."""
+
+from __future__ import annotations
+
+from pptx import Presentation
+from pptx.util import Inches, Pt, Emu
+from pptx.dml.color import RGBColor
+from pptx.enum.text import PP_ALIGN
+
+from ._utils import resolve_output_path
+
+
+def create_pptx(content: str, filename: str, *, content_type: str = "markdown",
+                output_dir: str | None = None) -> str:
+    """Generate a PPTX file from Markdown. Returns absolute path.
+
+    Slides are separated by `---` in Markdown.
+    First `#` heading becomes the slide title; remaining content becomes bullet points.
+    """
+    path = resolve_output_path(filename, ".pptx", output_dir)
+    prs = Presentation()
+    prs.slide_width = Inches(13.333)
+    prs.slide_height = Inches(7.5)
+
+    if content_type == "html":
+        # Strip tags for simple conversion
+        import re
+        content = re.sub(r"<[^>]+>", "", content)
+
+    slides_text = content.split("\n---\n") if "\n---\n" in content else content.split("\n---")
+
+    for slide_md in slides_text:
+        lines = [l for l in slide_md.strip().split("\n") if l.strip()]
+        if not lines:
+            continue
+
+        slide = prs.slides.add_slide(prs.slide_layouts[6])  # Blank layout
+
+        # Extract title (first # heading)
+        title_text = ""
+        body_lines = []
+        for line in lines:
+            stripped = line.strip()
+            if not title_text and stripped.startswith("#"):
+                title_text = stripped.lstrip("#").strip()
+            else:
+                body_lines.append(stripped)
+
+        # Add title
+        if title_text:
+            left = Inches(0.8)
+            top = Inches(0.5)
+            width = Inches(11.7)
+            height = Inches(1.2)
+            txBox = slide.shapes.add_textbox(left, top, width, height)
+            tf = txBox.text_frame
+            tf.word_wrap = True
+            p = tf.paragraphs[0]
+            p.text = title_text
+            p.font.size = Pt(36)
+            p.font.bold = True
+            p.font.color.rgb = RGBColor(0x1C, 0x28, 0x33)
+
+        # Add body content
+        if body_lines:
+            left = Inches(0.8)
+            top = Inches(2.0)
+            width = Inches(11.7)
+            height = Inches(4.5)
+            txBox = slide.shapes.add_textbox(left, top, width, height)
+            tf = txBox.text_frame
+            tf.word_wrap = True
+
+            for i, line in enumerate(body_lines):
+                if i == 0:
+                    p = tf.paragraphs[0]
+                else:
+                    p = tf.add_paragraph()
+
+                # Bullet points
+                if line.startswith("- ") or line.startswith("* "):
+                    p.text = line[2:]
+                    p.level = 0
+                    p.space_before = Pt(6)
+                elif line.startswith("  - ") or line.startswith("  * "):
+                    p.text = line[4:]
+                    p.level = 1
+                    p.space_before = Pt(4)
+                # Sub-headings
+                elif line.startswith("##"):
+                    p.text = line.lstrip("#").strip()
+                    p.font.size = Pt(24)
+                    p.font.bold = True
+                    p.space_before = Pt(12)
+                    continue
+                else:
+                    p.text = line
+
+                p.font.size = Pt(18)
+                p.font.color.rgb = RGBColor(0x33, 0x33, 0x33)
+
+    prs.save(str(path))
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/spreadsheet.py

@@ -0,0 +1,75 @@
+"""Spreadsheet generation — XLSX, CSV."""
+
+from __future__ import annotations
+
+import csv
+import io
+from typing import Any
+
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill, Alignment
+
+from ._utils import resolve_output_path
+
+
+def create_xlsx(data: list[dict] | list[list], filename: str, *,
+                output_dir: str | None = None, sheet_name: str = "Sheet1",
+                header_color: str = "4472C4") -> str:
+    """Generate an XLSX file from data. Returns absolute path.
+
+    Args:
+        data: List of dicts (keys as headers) or 2D list (first row as headers).
+    """
+    path = resolve_output_path(filename, ".xlsx", output_dir)
+    wb = Workbook()
+    ws = wb.active
+    ws.title = sheet_name
+
+    header_fill = PatternFill(start_color=header_color, end_color=header_color, fill_type="solid")
+    header_font = Font(bold=True, color="FFFFFF")
+
+    if data and isinstance(data[0], dict):
+        headers = list(data[0].keys())
+        ws.append(headers)
+        for row in data:
+            ws.append([row.get(h) for h in headers])
+    elif data and isinstance(data[0], list):
+        for row in data:
+            ws.append(row)
+    else:
+        wb.save(str(path))
+        return str(path.resolve())
+
+    # Style header row
+    for cell in ws[1]:
+        cell.fill = header_fill
+        cell.font = header_font
+        cell.alignment = Alignment(horizontal="center")
+
+    # Auto-width columns
+    for col in ws.columns:
+        max_len = 0
+        col_letter = col[0].column_letter
+        for cell in col:
+            val = str(cell.value) if cell.value is not None else ""
+            max_len = max(max_len, len(val))
+        ws.column_dimensions[col_letter].width = min(max_len + 4, 50)
+
+    wb.save(str(path))
+    return str(path.resolve())
+
+
+def create_csv(data: list[dict] | list[list], filename: str, *, output_dir: str | None = None) -> str:
+    """Generate a CSV file from data. Returns absolute path."""
+    path = resolve_output_path(filename, ".csv", output_dir)
+
+    with open(path, "w", newline="", encoding="utf-8-sig") as f:
+        if data and isinstance(data[0], dict):
+            writer = csv.DictWriter(f, fieldnames=data[0].keys())
+            writer.writeheader()
+            writer.writerows(data)
+        elif data and isinstance(data[0], list):
+            writer = csv.writer(f)
+            writer.writerows(data)
+
+    return str(path.resolve())

licos_dev_sdk-0.1.0/src/licos_dev_sdk/web.py

@@ -0,0 +1,61 @@
+"""Web file generation — HTML, Markdown."""
+
+from __future__ import annotations
+
+import mistune
+from jinja2 import Template
+
+from ._utils import resolve_output_path
+
+_DEFAULT_HTML_TEMPLATE = """\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>{{ title }}</title>
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+         max-width: 800px; margin: 2rem auto; padding: 0 1rem; line-height: 1.6; color: #333; }
+  table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
+  th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+  th { background-color: #f4f4f4; }
+  code { background: #f4f4f4; padding: 2px 6px; border-radius: 3px; }
+  pre { background: #f4f4f4; padding: 1rem; border-radius: 6px; overflow-x: auto; }
+  blockquote { border-left: 4px solid #ddd; margin-left: 0; padding-left: 1rem; color: #666; }
+</style>
+</head>
+<body>
+{{ body }}
+</body>
+</html>
+"""
+
+
+def markdown_to_html(markdown_content: str) -> str:
+    """Convert Markdown to HTML fragment."""
+    return mistune.html(markdown_content)
+
+
+def create_html(content: str, filename: str, *, output_dir: str | None = None,
+                template: str | None = None, content_type: str = "markdown") -> str:
+    """Generate an HTML file. Returns absolute path.
+
+    Args:
+        content: Markdown or raw HTML content.
+        content_type: "markdown" (default) or "html".
+        template: Custom Jinja2 template string. Must contain {{ body }}.
+    """
+    path = resolve_output_path(filename, ".html", output_dir)
+    body = markdown_to_html(content) if content_type == "markdown" else content
+    tmpl = Template(template or _DEFAULT_HTML_TEMPLATE)
+    html = tmpl.render(title=filename, body=body)
+    path.write_text(html, encoding="utf-8")
+    return str(path.resolve())
+
+
+def create_markdown(content: str, filename: str, *, output_dir: str | None = None) -> str:
+    """Write a Markdown file. Returns absolute path."""
+    path = resolve_output_path(filename, ".md", output_dir)
+    path.write_text(content, encoding="utf-8")
+    return str(path.resolve())