jostack-mdparse 0.1.0__py3-none-any.whl

jostack_mdparse/__init__.py

@@ -0,0 +1,7 @@
+"""jostack-mdparse: Markdown file parser and structured extraction tool."""
+
+__version__ = "0.0.0"
+
+from jostack_mdparse.extract import extract
+
+__all__ = ["extract", "__version__"]

jostack_mdparse/cli.py

@@ -0,0 +1,137 @@
+"""CLI entry point for jostack-mdparse."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from jostack_mdparse import __version__, extract
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="jostack-mdparse",
+        description="Markdown file parser and structured extraction tool",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # extract command
+    extract_parser = subparsers.add_parser(
+        "extract", help="Parse Markdown and output structured data"
+    )
+    _add_common_args(extract_parser)
+    _add_extract_options(extract_parser)
+
+    # toc command
+    toc_parser = subparsers.add_parser("toc", help="Print the table of contents (heading tree)")
+    _add_common_args(toc_parser)
+    toc_parser.add_argument(
+        "--heading-level",
+        default=None,
+        help="Filter by heading levels (comma-separated)",
+    )
+
+    # meta command
+    meta_parser = subparsers.add_parser("meta", help="Print frontmatter metadata as JSON")
+    _add_common_args(meta_parser)
+
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command == "extract":
+        result = extract(
+            args.input,
+            output_dir=args.output_dir,
+            format=args.format,
+            quiet=args.quiet,
+            heading_level=args.heading_level,
+            sections=args.sections,
+            include_frontmatter=args.include_frontmatter,
+            strip_html=args.strip_html,
+            include_code_blocks=args.include_code_blocks,
+            include_toc=args.include_toc,
+            flatten_lists=args.flatten_lists,
+            section_separator=args.section_separator,
+            normalize_links=args.normalize_links,
+        )
+        print(result)
+
+    elif args.command == "toc":
+        result = extract(
+            args.input,
+            format=args.format,
+            quiet=args.quiet,
+            include_toc=True,
+            heading_level=args.heading_level,
+        )
+        print(result)
+
+    elif args.command == "meta":
+        result = extract(
+            args.input,
+            format="json",
+            quiet=args.quiet,
+            include_frontmatter=True,
+        )
+        print(result)
+
+
+def _add_common_args(parser: argparse.ArgumentParser) -> None:
+    """Add common arguments shared across all commands."""
+    parser.add_argument("input", help="Path to Markdown file or directory")
+    parser.add_argument(
+        "-f",
+        "--format",
+        default="json",
+        choices=["json", "text", "html"],
+        help="Output format (default: json)",
+    )
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        default=False,
+        help="Suppress console logging output",
+    )
+
+
+def _add_extract_options(parser: argparse.ArgumentParser) -> None:
+    """Add extract-specific options from options.json."""
+    parser.add_argument("-o", "--output-dir", default=None, help="Output directory")
+    parser.add_argument(
+        "--heading-level", default=None, help="Filter by heading levels (comma-separated)"
+    )
+    parser.add_argument(
+        "-s", "--sections", default=None, help="Extract sections by heading text (comma-separated)"
+    )
+    parser.add_argument(
+        "--include-frontmatter", action="store_true", default=True, help="Include frontmatter"
+    )
+    parser.add_argument(
+        "--no-include-frontmatter", action="store_false", dest="include_frontmatter"
+    )
+    parser.add_argument("--strip-html", action="store_true", default=False, help="Strip HTML tags")
+    parser.add_argument(
+        "--include-code-blocks", action="store_true", default=True, help="Include code blocks"
+    )
+    parser.add_argument(
+        "--no-include-code-blocks", action="store_false", dest="include_code_blocks"
+    )
+    parser.add_argument(
+        "--include-toc", action="store_true", default=False, help="Add table of contents"
+    )
+    parser.add_argument(
+        "--flatten-lists", action="store_true", default=False, help="Flatten nested lists"
+    )
+    parser.add_argument(
+        "--section-separator", default=None, help="Section separator (use %%section-title%%)"
+    )
+    parser.add_argument(
+        "--normalize-links", action="store_true", default=False, help="Normalize relative links"
+    )

jostack_mdparse/extract.py

@@ -0,0 +1,337 @@
+"""Core extraction logic for jostack-mdparse."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+def extract(
+    input_path: Union[str, Path],
+    *,
+    output_dir: Optional[str] = None,
+    format: str = "json",
+    quiet: bool = False,
+    heading_level: Optional[str] = None,
+    sections: Optional[str] = None,
+    include_frontmatter: bool = True,
+    strip_html: bool = False,
+    include_code_blocks: bool = True,
+    include_toc: bool = False,
+    flatten_lists: bool = False,
+    section_separator: Optional[str] = None,
+    normalize_links: bool = False,
+) -> str:
+    """Extract structured data from a Markdown file.
+
+    Args:
+        input_path: Path to the Markdown file or directory.
+        output_dir: Directory where output files are written.
+        format: Output format (json, text, html).
+        quiet: Suppress console logging output.
+        heading_level: Filter by heading levels (comma-separated).
+        sections: Extract only sections matching heading text (comma-separated).
+        include_frontmatter: Include YAML/TOML frontmatter in output.
+        strip_html: Strip inline HTML tags from Markdown content.
+        include_code_blocks: Include fenced code blocks in output.
+        include_toc: Add a generated table of contents to the output.
+        flatten_lists: Flatten nested lists into a single level.
+        section_separator: Separator between sections in text output.
+        normalize_links: Convert relative links to absolute.
+
+    Returns:
+        Extracted content as a string in the specified format.
+    """
+    if quiet:
+        logging.disable(logging.CRITICAL)
+
+    path = Path(input_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Input path not found: {input_path}")
+
+    if path.is_dir():
+        files = sorted(path.glob("**/*.md"))
+        if not files:
+            raise FileNotFoundError(f"No Markdown files found in: {input_path}")
+        results = [_extract_file(f, **_build_kwargs(locals())) for f in files]
+        combined = _combine_results(results, format)
+    else:
+        combined = _extract_file(path, **_build_kwargs(locals()))
+
+    if output_dir:
+        out_path = Path(output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+        ext = {"json": ".json", "text": ".txt", "html": ".html"}.get(format, ".txt")
+        out_file = out_path / f"{path.stem}{ext}"
+        out_file.write_text(combined, encoding="utf-8")
+        logger.info("Output written to %s", out_file)
+
+    if quiet:
+        logging.disable(logging.NOTSET)
+
+    return combined
+
+
+def _build_kwargs(local_vars: dict[str, Any]) -> dict[str, Any]:
+    """Build kwargs dict from local variables, excluding non-option args."""
+    exclude = {
+        "input_path",
+        "path",
+        "output_dir",
+        "quiet",
+        "files",
+        "results",
+        "combined",
+        "f",
+    }
+    return {k: v for k, v in local_vars.items() if k not in exclude and not k.startswith("_")}
+
+
+def _extract_file(
+    file_path: Path,
+    *,
+    format: str = "json",
+    heading_level: Optional[str] = None,
+    sections: Optional[str] = None,
+    include_frontmatter: bool = True,
+    strip_html: bool = False,
+    include_code_blocks: bool = True,
+    include_toc: bool = False,
+    flatten_lists: bool = False,
+    section_separator: Optional[str] = None,
+    normalize_links: bool = False,
+) -> str:
+    """Extract structured data from a single Markdown file."""
+    content = file_path.read_text(encoding="utf-8")
+
+    frontmatter, body = _split_frontmatter(content)
+    parsed_sections = _parse_sections(body)
+
+    # Filter by heading level
+    if heading_level:
+        levels = {int(lv.strip()) for lv in heading_level.split(",")}
+        parsed_sections = [s for s in parsed_sections if s["level"] in levels]
+
+    # Filter by section name
+    if sections:
+        names = [n.strip().lower() for n in sections.split(",")]
+        parsed_sections = [
+            s for s in parsed_sections if any(n in s["title"].lower() for n in names)
+        ]
+
+    # Strip HTML
+    if strip_html:
+        for s in parsed_sections:
+            s["content"] = re.sub(r"<[^>]+>", "", s["content"])
+
+    # Remove code blocks
+    if not include_code_blocks:
+        for s in parsed_sections:
+            s["content"] = re.sub(r"```[\s\S]*?```", "", s["content"]).strip()
+
+    # Flatten lists
+    if flatten_lists:
+        for s in parsed_sections:
+            s["content"] = _flatten_lists(s["content"])
+
+    # Normalize links
+    if normalize_links:
+        base_dir = str(file_path.parent)
+        for s in parsed_sections:
+            s["content"] = _normalize_links(s["content"], base_dir)
+
+    # Build TOC
+    toc = _build_toc(parsed_sections) if include_toc else None
+
+    # Format output
+    if format == "json":
+        return _format_json(file_path, frontmatter, parsed_sections, toc, include_frontmatter)
+    elif format == "html":
+        return _format_html(file_path, frontmatter, parsed_sections, toc, include_frontmatter)
+    else:
+        return _format_text(
+            file_path,
+            frontmatter,
+            parsed_sections,
+            toc,
+            include_frontmatter,
+            section_separator,
+        )
+
+
+def _split_frontmatter(content: str) -> tuple[Optional[dict[str, Any]], str]:
+    """Split YAML/TOML frontmatter from body."""
+    if content.startswith("---"):
+        parts = content.split("---", 2)
+        if len(parts) >= 3:
+            try:
+                # Simple YAML-like parsing (key: value)
+                fm: dict[str, Any] = {}
+                for line in parts[1].strip().splitlines():
+                    if ":" in line:
+                        key, _, value = line.partition(":")
+                        fm[key.strip()] = value.strip()
+                return fm, parts[2].strip()
+            except Exception:
+                pass
+    return None, content
+
+
+def _parse_sections(body: str) -> list[dict[str, Any]]:
+    """Parse Markdown body into sections based on headings."""
+    sections: list[dict[str, Any]] = []
+    current: Optional[dict[str, Any]] = None
+    lines: list[str] = []
+
+    for line in body.splitlines():
+        heading_match = re.match(r"^(#{1,6})\s+(.+)$", line)
+        if heading_match:
+            if current is not None:
+                current["content"] = "\n".join(lines).strip()
+                sections.append(current)
+            level = len(heading_match.group(1))
+            title = heading_match.group(2).strip()
+            current = {"level": level, "title": title, "content": ""}
+            lines = []
+        else:
+            lines.append(line)
+
+    # Handle remaining content
+    if current is not None:
+        current["content"] = "\n".join(lines).strip()
+        sections.append(current)
+    elif lines:
+        content = "\n".join(lines).strip()
+        if content:
+            sections.append({"level": 0, "title": "", "content": content})
+
+    return sections
+
+
+def _build_toc(sections: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Build table of contents from sections."""
+    return [{"level": s["level"], "title": s["title"]} for s in sections if s["level"] > 0]
+
+
+def _flatten_lists(content: str) -> str:
+    """Flatten nested lists to a single level."""
+    result = []
+    for line in content.splitlines():
+        match = re.match(r"^(\s*)[-*+]\s+(.+)$", line)
+        if match:
+            result.append(f"- {match.group(2)}")
+        else:
+            result.append(line)
+    return "\n".join(result)
+
+
+def _normalize_links(content: str, base_dir: str) -> str:
+    """Convert relative links to absolute paths."""
+
+    def replace_link(m: re.Match[str]) -> str:
+        text, url = m.group(1), m.group(2)
+        if not url.startswith(("http://", "https://", "#", "mailto:")):
+            url = str(Path(base_dir) / url)
+        return f"[{text}]({url})"
+
+    return re.sub(r"\[([^\]]+)\]\(([^)]+)\)", replace_link, content)
+
+
+def _format_json(
+    file_path: Path,
+    frontmatter: Optional[dict[str, Any]],
+    sections: list[dict[str, Any]],
+    toc: Optional[list[dict[str, Any]]],
+    include_frontmatter: bool,
+) -> str:
+    """Format output as JSON."""
+    result: dict[str, Any] = {"source": str(file_path)}
+    if include_frontmatter and frontmatter:
+        result["frontmatter"] = frontmatter
+    if toc:
+        result["toc"] = toc
+    result["sections"] = sections
+    return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+def _format_text(
+    file_path: Path,
+    frontmatter: Optional[dict[str, Any]],
+    sections: list[dict[str, Any]],
+    toc: Optional[list[dict[str, Any]]],
+    include_frontmatter: bool,
+    section_separator: Optional[str] = None,
+) -> str:
+    """Format output as plain text."""
+    parts: list[str] = []
+
+    if include_frontmatter and frontmatter:
+        fm_lines = [f"{k}: {v}" for k, v in frontmatter.items()]
+        parts.append("\n".join(fm_lines))
+
+    if toc:
+        toc_lines = ["Table of Contents:"]
+        for entry in toc:
+            indent = "  " * (entry["level"] - 1)
+            toc_lines.append(f"{indent}- {entry['title']}")
+        parts.append("\n".join(toc_lines))
+
+    for s in sections:
+        if section_separator and s["title"]:
+            sep = section_separator.replace("%section-title%", s["title"])
+            parts.append(sep)
+        if s["title"]:
+            parts.append(f"{'#' * s['level']} {s['title']}")
+        if s["content"]:
+            parts.append(s["content"])
+
+    return "\n\n".join(parts)
+
+
+def _format_html(
+    file_path: Path,
+    frontmatter: Optional[dict[str, Any]],
+    sections: list[dict[str, Any]],
+    toc: Optional[list[dict[str, Any]]],
+    include_frontmatter: bool,
+) -> str:
+    """Format output as HTML."""
+    parts: list[str] = ["<!DOCTYPE html>", "<html>", "<body>"]
+
+    if include_frontmatter and frontmatter:
+        parts.append("<dl>")
+        for k, v in frontmatter.items():
+            parts.append(f"  <dt>{k}</dt><dd>{v}</dd>")
+        parts.append("</dl>")
+
+    if toc:
+        parts.append("<nav><ul>")
+        for entry in toc:
+            parts.append(f'  <li class="level-{entry["level"]}">{entry["title"]}</li>')
+        parts.append("</ul></nav>")
+
+    for s in sections:
+        if s["title"]:
+            tag = f"h{min(s['level'], 6)}"
+            parts.append(f"<{tag}>{s['title']}</{tag}>")
+        if s["content"]:
+            paragraphs = s["content"].split("\n\n")
+            for p in paragraphs:
+                if p.strip():
+                    parts.append(f"<p>{p.strip()}</p>")
+
+    parts.extend(["</body>", "</html>"])
+    return "\n".join(parts)
+
+
+def _combine_results(results: list[str], format: str) -> str:
+    """Combine multiple file results."""
+    if format == "json":
+        parsed = [json.loads(r) for r in results]
+        return json.dumps(parsed, ensure_ascii=False, indent=2)
+    return "\n\n---\n\n".join(results)

jostack_mdparse-0.1.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: jostack-mdparse
+Version: 0.1.0
+Summary: Markdown file parser and structured extraction tool
+Project-URL: Repository, https://github.com/hyunhee-jo/jostack-mdparse
+Project-URL: Issues, https://github.com/hyunhee-jo/jostack-mdparse/issues
+Project-URL: Changelog, https://github.com/hyunhee-jo/jostack-mdparse/blob/main/CHANGELOG.md
+Author: hyunhee-jo
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: cli,extraction,markdown,parser,structured-data
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<!-- AI-AGENT-SUMMARY
+name: jostack-mdparse
+category: Markdown parser, structured extraction
+license: MIT
+solves: [Parse Markdown files into structured data, section-level extraction]
+input: Markdown files (.md)
+output: JSON, text, HTML
+sdk: Python
+requirements: Python 3.10+
+key-differentiators: [CLI + Python API, section filtering, frontmatter extraction, options.json SsoT]
+-->
+
+# jostack-mdparse
+
+[![CI](https://github.com/hyunhee-jo/jostack-mdparse/actions/workflows/ci.yml/badge.svg)](https://github.com/hyunhee-jo/jostack-mdparse/actions/workflows/ci.yml)
+[![License-Apache_2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+Markdown file parser and structured extraction tool (CLI + Python API).
+
+## Installation
+
+```bash
+pip install jostack-mdparse
+```
+
+## Quick Start
+
+### CLI
+
+```bash
+# Extract as JSON
+jostack-mdparse extract README.md -f json
+
+# Extract specific sections
+jostack-mdparse extract docs/ -s "Installation,Usage" -f text
+
+# Print table of contents
+jostack-mdparse toc README.md
+
+# Print frontmatter metadata
+jostack-mdparse meta blog-post.md
+```
+
+### Python API
+
+```python
+from jostack_mdparse import extract
+
+# Basic extraction
+result = extract("README.md", format="json")
+
+# Filter by heading level
+result = extract("docs/guide.md", heading_level="1,2", format="text")
+
+# Extract specific sections
+result = extract("README.md", sections="Usage", strip_html=True)
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `extract` | Parse Markdown and output structured data (JSON, text, HTML) |
+| `toc` | Print the table of contents (heading tree) |
+| `meta` | Print frontmatter metadata as JSON |
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `output-dir` | `str` | `None` | Directory where output files are written |
+| `format` | `str` | `"json"` | Output format: json, text, html |
+| `quiet` | `bool` | `False` | Suppress console logging output |
+| `heading-level` | `str` | `None` | Filter by heading levels (comma-separated) |
+| `sections` | `str` | `None` | Extract sections by heading text (comma-separated) |
+| `include-frontmatter` | `bool` | `True` | Include YAML/TOML frontmatter in output |
+| `strip-html` | `bool` | `False` | Strip inline HTML tags |
+| `include-code-blocks` | `bool` | `True` | Include fenced code blocks |
+| `include-toc` | `bool` | `False` | Add generated table of contents |
+| `flatten-lists` | `bool` | `False` | Flatten nested lists |
+| `section-separator` | `str` | `None` | Separator between sections in text output |
+| `normalize-links` | `bool` | `False` | Convert relative links to absolute |
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e .
+
+# Run tests
+make test
+
+# Run linting
+make lint
+
+# Format code
+make format
+```
+
+## License
+
+[MIT](LICENSE)

jostack_mdparse-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+jostack_mdparse/__init__.py,sha256=TgaUrnpDUMbByXtr1G8DQt5mDgMLockJFMDHQErxiBY,182
+jostack_mdparse/cli.py,sha256=EEGMSNP03HENT46tRHHDDWrrRqltR8WZ5tQT97b64GA,4533
+jostack_mdparse/extract.py,sha256=H51MoayFTP7LqXB2ITlRoZGUQj-QWSN7jsDWYwMqFTM,10998
+jostack_mdparse-0.1.0.dist-info/METADATA,sha256=zqYHWmvnVp67BgYS92fGIZoz0kGHs7i0MuescUxY-WM,3903
+jostack_mdparse-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+jostack_mdparse-0.1.0.dist-info/entry_points.txt,sha256=trtxIzsJVfGvE37cU2r7cQtJ5U5tmQGyvTM0VdJem14,61
+jostack_mdparse-0.1.0.dist-info/licenses/LICENSE,sha256=1ne3lp-gb7pRBz-AKpp-8RpBdYKZ5UG394Q43fQx0lk,10709
+jostack_mdparse-0.1.0.dist-info/RECORD,,

jostack_mdparse-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

jostack_mdparse-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jostack-mdparse = jostack_mdparse.cli:main

jostack_mdparse-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 hyunhee-jo
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.