afterpython 0.1.1__tar.gz

afterpython-0.1.1/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: afterpython
+Version: 0.1.1
+Summary: CLI tool to streamline Python package maintenance and generate a dedicated project website
+Keywords: package-maintenance,project-website,static-site-generator,developer-tools,documentation,cli-tool,ci/cd,mystmd,semantic-release,python-packaging
+Author: Stephen Yau
+Author-email: Stephen Yau <softwareentrepreneer+afterpython@gmail.com>
+License-Expression: Apache-2.0
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click>=8.3.1
+Requires-Dist: trogon>=0.6.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: tomlkit>=0.13.3
+Requires-Dist: ruamel-yaml>=0.18.16
+Requires-Dist: gitpython>=3.1.45
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: pyproject-metadata>=0.10.0
+Requires-Dist: mystmd>=1.7.0
+Requires-Dist: pdoc>=16.0.0
+Requires-Dist: ruff>=0.14.8
+Requires-Dist: pre-commit>=4.5.0
+Requires-Dist: commitizen>=4.10.0
+Requires-Python: >=3.11
+Project-URL: documentation, https://afterpython.afterpython.org/doc
+Project-URL: homepage, https://afterpython.afterpython.org
+Project-URL: repository, https://github.com/AfterPythonOrg/afterpython
+Description-Content-Type: text/markdown
+
+# AfterPython: Python Package Maintenance Toolkit and Project Website Generator
+
+[![afterpython](https://afterpython.org/shield.svg)](https://afterpython.org)
+![PyPI downloads](https://img.shields.io/pypi/dm/afterpython)
+[![PyPI](https://img.shields.io/pypi/v/afterpython.svg)](https://pypi.org/project/afterpython)
+![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/afterpython)
+[![Discussions](https://img.shields.io/badge/Discussions-Let's%20Chat-green)](https://github.com/AfterPythonOrg/afterpython/discussions)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/AfterPythonOrg/afterpython)
+<!-- [![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh) -->
+
+
+[MyST]: https://mystmd.org
+[MyST Markdown]: https://mystmd.org/spec/
+[Jupyter Notebook]: https://jupyter.org
+[pre-commit]: https://pre-commit.com
+[pagefind]: https://pagefind.app
+[SemVer]: https://semver.org
+[pdoc]: https://pdoc.dev/
+[GitHub Actions]: https://github.com/features/actions
+[PyTorch]: https://pytorch.org
+[Scikit-Learn]: https://scikit-learn.org
+[WebLLM]: https://webllm.mlc.ai/
+[project-website-template]: https://github.com/AfterPythonOrg/project-website-template
+[commitizen]: https://github.com/commitizen-tools/commitizen
+[uv]: https://docs.astral.sh/uv/
+[ruff]: https://docs.astral.sh/ruff/
+
+
+## Problem
+Going from **writing Python code to publishing and maintaining a package** is **time-consuming**.
+First-time maintainers must learn multiple tools and concepts, e.g. [MyST], [SemVer], CI/CD ([pre-commit] hooks, GitHub workflows), and they often spending hours just to deploy a documentation site whereas well-resourced projects like [PyTorch] and [Scikit-Learn] have **dedicated websites** that serve as their project hubs.
+
+
+## Solution
+`afterpython` **automates** the tedious parts of Python package maintenance and generates a **project website** for **building community** and **hosting content** such as documentation, **blog posts**, tutorials, examples and more — empowering more developers to write packages with ease.
+
+---
+`afterpython` is a CLI tool that **abstracts away the complexity** of **content writing, website deployment, and package release/maintenance** by providing an opinionated set of modern tools — so you don’t have to spend time selecting or learning anything beyond the basics.
+
+
+## Core Features
+- [x] Write content directly in [MyST Markdown] or [Jupyter Notebook]
+- [x] Go from writing to **website deployment in minutes** — no need to learn any of the underlying tools
+- [x] Centralize all your content in a modern, **unified project website** — from documentation to blog posts
+- [x] Zero-config orchestration — Pre-configured modern tooling with sane defaults (see [Tech Stack](#tech-stack)), so you can start maintaining packages immediately **without learning each tool**
+- [ ] Export content as PDF — for example, combine all blog posts into a single PDF file
+- [ ] **⚡ Full-text search** across **ALL** your content in your website — docs, blogs, tutorials, everything
+- [ ] **🤖 Embedded AI Chatbot** that answers questions directly using an in-browser LLM — at no cost
+
+---
+## Project Website
+> The project website for `afterpython` is created using `afterpython` itself. See the [**website**](https://afterpython.afterpython.org).
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="afterpython/static/website-dark.png">
+  <source media="(prefers-color-scheme: light)" srcset="afterpython/static/website-light.png">
+  <img alt="Project Website" src="afterpython/static/website-light.png">
+</picture>
+
+You can create your own website too and deploy it to GitHub Pages in **less than a minute**! See [Quickstart](https://afterpython.afterpython.org/doc/quickstart).
+
+---
+## Installation
+```bash
+# install afterpython as a dev dependency
+uv add --dev afterpython
+
+# initialize afterpython
+ap init
+```
+
+
+---
+## CLI Commands
+```bash
+# show all commands
+ap --help
+
+# or use terminal UI (TUI)
+ap tui
+```
+
+
+---
+## Tech Stack
+- [MyST]
+- [project-website-template]
+- [pre-commit]
+- [GitHub Actions]
+- [pdoc]
+- [commitizen]
+- [uv]
+- [ruff]
+- [pagefind]
+- [WebLLM]
+<!-- - ty -->
+<!-- - [pixi] -->

afterpython-0.1.1/README.md

@@ -0,0 +1,96 @@
+# AfterPython: Python Package Maintenance Toolkit and Project Website Generator
+
+[![afterpython](https://afterpython.org/shield.svg)](https://afterpython.org)
+![PyPI downloads](https://img.shields.io/pypi/dm/afterpython)
+[![PyPI](https://img.shields.io/pypi/v/afterpython.svg)](https://pypi.org/project/afterpython)
+![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/afterpython)
+[![Discussions](https://img.shields.io/badge/Discussions-Let's%20Chat-green)](https://github.com/AfterPythonOrg/afterpython/discussions)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/AfterPythonOrg/afterpython)
+<!-- [![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh) -->
+
+
+[MyST]: https://mystmd.org
+[MyST Markdown]: https://mystmd.org/spec/
+[Jupyter Notebook]: https://jupyter.org
+[pre-commit]: https://pre-commit.com
+[pagefind]: https://pagefind.app
+[SemVer]: https://semver.org
+[pdoc]: https://pdoc.dev/
+[GitHub Actions]: https://github.com/features/actions
+[PyTorch]: https://pytorch.org
+[Scikit-Learn]: https://scikit-learn.org
+[WebLLM]: https://webllm.mlc.ai/
+[project-website-template]: https://github.com/AfterPythonOrg/project-website-template
+[commitizen]: https://github.com/commitizen-tools/commitizen
+[uv]: https://docs.astral.sh/uv/
+[ruff]: https://docs.astral.sh/ruff/
+
+
+## Problem
+Going from **writing Python code to publishing and maintaining a package** is **time-consuming**.
+First-time maintainers must learn multiple tools and concepts, e.g. [MyST], [SemVer], CI/CD ([pre-commit] hooks, GitHub workflows), and they often spending hours just to deploy a documentation site whereas well-resourced projects like [PyTorch] and [Scikit-Learn] have **dedicated websites** that serve as their project hubs.
+
+
+## Solution
+`afterpython` **automates** the tedious parts of Python package maintenance and generates a **project website** for **building community** and **hosting content** such as documentation, **blog posts**, tutorials, examples and more — empowering more developers to write packages with ease.
+
+---
+`afterpython` is a CLI tool that **abstracts away the complexity** of **content writing, website deployment, and package release/maintenance** by providing an opinionated set of modern tools — so you don’t have to spend time selecting or learning anything beyond the basics.
+
+
+## Core Features
+- [x] Write content directly in [MyST Markdown] or [Jupyter Notebook]
+- [x] Go from writing to **website deployment in minutes** — no need to learn any of the underlying tools
+- [x] Centralize all your content in a modern, **unified project website** — from documentation to blog posts
+- [x] Zero-config orchestration — Pre-configured modern tooling with sane defaults (see [Tech Stack](#tech-stack)), so you can start maintaining packages immediately **without learning each tool**
+- [ ] Export content as PDF — for example, combine all blog posts into a single PDF file
+- [ ] **⚡ Full-text search** across **ALL** your content in your website — docs, blogs, tutorials, everything
+- [ ] **🤖 Embedded AI Chatbot** that answers questions directly using an in-browser LLM — at no cost
+
+---
+## Project Website
+> The project website for `afterpython` is created using `afterpython` itself. See the [**website**](https://afterpython.afterpython.org).
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="afterpython/static/website-dark.png">
+  <source media="(prefers-color-scheme: light)" srcset="afterpython/static/website-light.png">
+  <img alt="Project Website" src="afterpython/static/website-light.png">
+</picture>
+
+You can create your own website too and deploy it to GitHub Pages in **less than a minute**! See [Quickstart](https://afterpython.afterpython.org/doc/quickstart).
+
+---
+## Installation
+```bash
+# install afterpython as a dev dependency
+uv add --dev afterpython
+
+# initialize afterpython
+ap init
+```
+
+
+---
+## CLI Commands
+```bash
+# show all commands
+ap --help
+
+# or use terminal UI (TUI)
+ap tui
+```
+
+
+---
+## Tech Stack
+- [MyST]
+- [project-website-template]
+- [pre-commit]
+- [GitHub Actions]
+- [pdoc]
+- [commitizen]
+- [uv]
+- [ruff]
+- [pagefind]
+- [WebLLM]
+<!-- - ty -->
+<!-- - [pixi] -->

afterpython-0.1.1/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "afterpython"
+version = "0.1.1"
+description = "CLI tool to streamline Python package maintenance and generate a dedicated project website"
+license = "Apache-2.0"
+authors = [
+    { name = "Stephen Yau", email = "softwareentrepreneer+afterpython@gmail.com" },
+]
+readme = "README.md"
+keywords = [
+    "package-maintenance",
+    "project-website",
+    "static-site-generator",
+    "developer-tools",
+    "documentation",
+    "cli-tool",
+    "ci/cd",
+    "mystmd",
+    "semantic-release",
+    "python-packaging",
+]
+classifiers = [
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Software Development :: Documentation",
+    "Typing :: Typed",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    # "Programming Language :: Python :: 3.14",
+]
+requires-python = ">=3.11"
+dependencies = [
+    "click>=8.3.1",
+    "trogon>=0.6.0",
+    "httpx>=0.28.1",
+    "tomlkit>=0.13.3",
+    "ruamel-yaml>=0.18.16",
+    "gitpython>=3.1.45",
+    # "pygithub>=2.8.1",
+    "python-dotenv>=1.2.1",
+    "pyproject-metadata>=0.10.0",
+    # "jupytext>=1.18.1",
+    # "jinja2>=3.1.6",
+    "mystmd>=1.7.0",
+    "pdoc>=16.0.0",
+    "ruff>=0.14.8",
+    "pre-commit>=4.5.0",
+    "commitizen>=4.10.0",
+    # "python-semantic-release>=10.5.2",
+]
+
+[project.urls]
+homepage = "https://afterpython.afterpython.org"
+repository = "https://github.com/AfterPythonOrg/afterpython"
+documentation = "https://afterpython.afterpython.org/doc"
+
+[project.scripts]
+ap = "afterpython.main:run_cli"
+pcu = "afterpython.main:run_pcu"
+
+[tool.uv]
+# override the restrictive version constraints "platformdirs~=4.2.2", "nodeenv~=1.9.1" in package `mystmd`
+override-dependencies = ["platformdirs>=4.5.0", "nodeenv>=1.9.1"]
+
+[build-system]
+requires = ["uv_build>=0.9.16,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "afterpython"
+module-root = "src"

afterpython-0.1.1/src/afterpython/__init__.py

@@ -0,0 +1,13 @@
+# import builtins
+# from pprint import pprint
+from importlib.metadata import version
+
+from afterpython._paths import Paths
+
+# make pprint available in the global namespace
+# builtins.pprint = pprint
+
+paths = Paths()
+
+__version__ = version("afterpython")
+__all__ = ("__version__", "paths")

afterpython-0.1.1/src/afterpython/_io/toml.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from tomlkit.toml_document import TOMLDocument
+
+import tomlkit
+
+
+# VIBE-CODED
+def _from_tomlkit(value):
+    """Recursively convert tomlkit objects to plain Python data structures.
+
+    This ensures compatibility with other libraries (like ruamel.yaml):
+    - tomlkit containers → plain Python containers
+    - tomlkit primitives → plain Python primitives
+    """
+    from tomlkit.items import AoT, Array, InlineTable, Table
+
+    if value is None:
+        return None
+
+    # Check containers first (these are the problematic ones)
+    if isinstance(value, (Table, InlineTable)):
+        # tomlkit dict-like → plain dict
+        return {k: _from_tomlkit(v) for k, v in value.items()}
+    elif isinstance(value, (Array, AoT)):
+        # tomlkit array → plain list
+        return [_from_tomlkit(item) for item in value]
+    elif isinstance(value, dict):
+        # Already a dict, but recurse to handle nested tomlkit objects
+        return {k: _from_tomlkit(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        # Already a list, but recurse to handle nested tomlkit objects
+        return [_from_tomlkit(item) for item in value]
+
+    # Primitives - tomlkit primitives inherit from Python types
+    # Just convert explicitly to be safe
+    elif isinstance(value, bool):  # MUST check bool before int!
+        return bool(value)
+    elif isinstance(value, int):
+        return int(value)
+    elif isinstance(value, float):
+        return float(value)
+    elif isinstance(value, str):
+        return str(value)
+    else:
+        # datetime, date, time, or already plain Python type
+        return value
+
+
+# VIBE-CODED
+def _to_tomlkit(value):
+    """Recursively convert Python data structures to tomlkit objects.
+
+    This ensures proper TOML formatting:
+    - List of dicts → array of inline tables: [{key = val}]
+    - Nested dicts → nested tables with proper structure
+    """
+    from tomlkit import array, inline_table
+
+    if value is None:
+        return None
+
+    if isinstance(value, dict):
+        # Plain dict → recursively convert values
+        return {k: _to_tomlkit(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        if not value:
+            # Empty list → empty tomlkit array
+            return array()
+
+        # Check if ALL items are dicts (should be inline tables)
+        if all(isinstance(item, dict) for item in value):
+            arr = array()
+            for item in value:
+                tbl = inline_table()
+                # Recursively convert the dict values
+                tbl.update({k: _to_tomlkit(v) for k, v in item.items()})
+                arr.append(tbl)
+            return arr
+        else:
+            # Mixed or non-dict items → regular array
+            arr = array()
+            for item in value:
+                arr.append(_to_tomlkit(item))
+            return arr
+    else:
+        # Primitives (str, int, float, bool, datetime, etc.)
+        # tomlkit handles these natively
+        return value
+
+
+def read_toml(file_path: Path) -> TOMLDocument:
+    with open(file_path, "rb") as f:
+        data: TOMLDocument = tomlkit.parse(f.read())
+    return data
+
+
+def write_toml(file_path: Path, data: TOMLDocument | dict):
+    with open(file_path, "w") as f:
+        f.write(tomlkit.dumps(data))

afterpython-0.1.1/src/afterpython/_io/yaml.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from ruamel.yaml import YAML
+from ruamel.yaml.comments import CommentedMap
+
+
+def _get_yaml() -> YAML:
+    """Get configured YAML instance that preserves order, comments, and formatting"""
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    yaml.default_flow_style = False
+    yaml.width = 4096  # Prevent line wrapping
+    return yaml
+
+
+def read_yaml(file_path: Path) -> CommentedMap:
+    yaml = _get_yaml()
+    with open(file_path) as f:
+        return yaml.load(f)
+
+
+def write_yaml(file_path: Path, data: dict):
+    """Write YAML data"""
+    yaml = _get_yaml()
+    with open(file_path, "w") as f:
+        yaml.dump(data, f)

afterpython-0.1.1/src/afterpython/_paths.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class Paths:
+    package_path: Path = field(init=False)
+    templates_path: Path = field(init=False)
+    user_path: Path = field(init=False)
+    pyproject_path: Path = field(init=False)
+    afterpython_path: Path = field(init=False)
+    website_path: Path = field(init=False)
+    build_path: Path = field(init=False)
+    static_path: Path = field(init=False)
+
+    def __post_init__(self):
+        # package path is the path to the afterpython package in user's site-packages
+        self.package_path = Path(__file__).resolve().parents[0]
+        self.templates_path = self.package_path / "templates"
+        self.user_path = self._find_project_root()
+        self.pyproject_path = self.user_path / "pyproject.toml"
+        self.afterpython_path = self.user_path / "afterpython"
+        self.website_path = self.afterpython_path / "_website"
+        self.build_path = self.afterpython_path / "_build"
+        self.static_path = self.afterpython_path / "static"
+
+    def _find_project_root(self) -> Path:
+        """Find the project root by looking for pyproject.toml in current or parent directories."""
+        current = Path.cwd()
+
+        # Check current directory and all parents
+        for path in [current, *current.parents]:
+            if (path / "pyproject.toml").exists():
+                return path
+
+        # If no pyproject.toml found, raise an error like uv does
+        raise FileNotFoundError(
+            "No pyproject.toml found in current directory or any parent directory"
+        )

afterpython-0.1.1/src/afterpython/_typing.py

@@ -0,0 +1,4 @@
+from typing import Literal, TypeAlias
+
+NodeEnv: TypeAlias = dict[str, str]
+tContentType = Literal["doc", "blog", "tutorial", "example", "guide"]

afterpython-0.1.1/src/afterpython/builders/__init__.py

@@ -0,0 +1,17 @@
+from afterpython.builders.content_json import build_content_json
+from afterpython.builders.index_md import (
+    create_placeholder_index_md_files,
+    delete_placeholder_index_md_files,
+)
+from afterpython.builders.jupyter_notebook import build_jupyter_notebooks
+from afterpython.builders.markdown import build_markdown
+from afterpython.builders.metadata import build_metadata
+
+__all__ = (
+    "build_content_json",
+    "build_jupyter_notebooks",
+    "build_markdown",
+    "build_metadata",
+    "create_placeholder_index_md_files",
+    "delete_placeholder_index_md_files",
+)

afterpython-0.1.1/src/afterpython/builders/content_json.py

@@ -0,0 +1,131 @@
+"""
+Build {content_type}.json for non-doc content type (blog, tutorial, example, guide)
+
+Combines all individual content JSON files from MyST build output into a single
+manifest file for SvelteKit to consume (e.g., blog.json, tutorial.json).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from afterpython._typing import tContentType
+
+import json
+from pathlib import Path
+
+import click
+
+import afterpython as ap
+from afterpython.const import CONTENT_TYPES
+
+
+def standardize_data(content_type: tContentType, content: dict) -> dict:
+    """
+    Standardize the content dictionary to a single level.
+    """
+    from afterpython.tools._afterpython import read_afterpython
+
+    afterpython = read_afterpython()
+    website = afterpython.get("website", {})
+    content_type_config = website.get(content_type, {})
+    featured_post = content_type_config.get("featured_post", "")
+
+    frontmatter = content.get("frontmatter", {})
+    # e.g. featured_post = "blog4.md" or "blog4"
+    is_featured = content["slug"] == featured_post or content["location"].endswith(
+        featured_post
+    )
+    return {
+        "version": content["version"],
+        "slug": content["slug"],
+        "location": content["location"],
+        "featured": is_featured,
+        # frontmatter fields
+        "title": frontmatter.get("title", ""),
+        "description": frontmatter.get("description", ""),
+        "tags": frontmatter.get("tags", []),
+        "date": frontmatter.get("date", ""),
+        "thumbnail": frontmatter.get("thumbnail", ""),
+        "thumbnailOptimized": frontmatter.get("thumbnailOptimized", ""),
+        "authors": frontmatter.get("authors", []),
+    }
+
+
+def convert_paths(content_type: tContentType, output_file: Path):
+    """
+    Convert paths (generated by MyST build) in the content_json file to use the new paths in the build output.
+    e.g. convert /blog_thumbnail-08d4f63a34eb7b55b6a00c25218c3295.png to /blog/build/blog_thumbnail-08d4f63a34eb7b55b6a00c25218c3295.png
+    """
+    with open(output_file, encoding="utf-8") as f:
+        content = json.load(f)
+
+    for item in content:
+        if not item.get("thumbnailOptimized"):
+            item["thumbnailOptimized"] = item["thumbnail"]
+        item["thumbnail"] = f"/{content_type}/build" + item["thumbnail"]
+        item["thumbnailOptimized"] = (
+            f"/{content_type}/build" + item["thumbnailOptimized"]
+        )
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(content, f, indent=2, ensure_ascii=False)
+
+    click.echo(f"Completed path conversion in {output_file}")
+
+
+def build_content_json():
+    """Build {content_type}.json manifest for non-doc content types.
+
+    Reads all JSON files from afterpython/_build/{content_type}/site/content/
+    (excluding index.json) and combines them into a single manifest file at
+    afterpython/_build/{content_type}.json.
+
+    This manifest is used by SvelteKit landing pages to list all content items.
+
+    Args:
+        content_type: Content type (blog, tutorial, example, guide)
+    """
+    for content_type in CONTENT_TYPES:
+        if content_type == "doc":
+            continue  # Doc doesn't need a combined manifest
+
+        content_path = ap.paths.afterpython_path / content_type
+        content_dir = content_path / "_build" / "site" / "content"
+        myst_yml_path = content_path / "myst.yml"
+        if (
+            not content_path.exists()
+            or not myst_yml_path.exists()
+            or not content_dir.exists()
+        ):
+            click.echo(f"Skipping {content_type}.json (missing files)")
+            continue
+
+        click.echo(f"Building {content_type}.json...")
+
+        # Collect all JSON files except index.json, which is created by a placeholder index.md file
+        content_items = []
+        for json_file in content_dir.glob("*.json"):
+            if json_file.stem == "index":
+                continue  # Skip index.json
+
+            try:
+                with open(json_file, encoding="utf-8") as f:
+                    data = json.load(f)
+
+                # Preserve all data from MyST JSON files
+                # The project-website-template will parse the fields it needs
+                content_items.append(standardize_data(content_type, data))
+            except (json.JSONDecodeError, KeyError) as e:
+                click.echo(f"Warning: Failed to parse {json_file}: {e}")
+                continue
+
+        # Write combined manifest
+        output_file = ap.paths.build_path / f"{content_type}.json"
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(content_items, f, indent=2, ensure_ascii=False)
+
+        click.echo(f"Generated {output_file} with {len(content_items)} items")
+
+        convert_paths(content_type, output_file)