sardine-cms-cli 0.1.0__py3-none-any.whl

cms_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Sardine CMS command line interface."""
+
+__version__ = "0.1.0"

cms_cli/app.py

@@ -0,0 +1,227 @@
+"""The `cms` command line: thin wiring from project config to services."""
+
+import http.server
+from functools import partial
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cms_build import build_site, create_target, create_theme
+from cms_build.builder import Artifact
+from cms_validation import Report, RuleSet, ValidationContext, default_ruleset
+
+from cms_cli.project import PROJECT_FILE, Project, load_project
+from cms_cli.seed import seed
+
+app = typer.Typer(add_completion=False, no_args_is_help=True)
+
+ProjectDir = Annotated[
+    Path,
+    typer.Option("--project", "-p", help="Project directory containing sardine.toml"),
+]
+
+
+def _project(directory: Path) -> Project:
+    try:
+        return load_project(directory.resolve())
+    except FileNotFoundError as error:
+        typer.echo(f"error: {error}", err=True)
+        raise typer.Exit(code=2) from error
+
+
+def _validate(project: Project) -> Report:
+    content = project.load_content()
+    ruleset = RuleSet(rules=default_ruleset())
+    context = ValidationContext(
+        required_languages=project.site.languages,
+        known_categories=(
+            tuple(sorted(project.site.categories)) if project.site.categories else None
+        ),
+    )
+    return ruleset.run(content, context)
+
+
+def _report(report: Report) -> None:
+    for issue in report.issues:
+        typer.echo(str(issue))
+    typer.echo(f"{len(report.errors)} error(s), {len(report.warnings)} warning(s)")
+
+
+def _write_artifact(artifact: Artifact, output: Path) -> int:
+    output.mkdir(parents=True, exist_ok=True)
+    root = output.resolve()
+    for path in artifact.paths():
+        destination = (root / path).resolve()
+        if not destination.is_relative_to(root):
+            raise ValueError(f"artifact path escapes the output directory: {path}")
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(artifact.files[path])
+    return len(artifact.paths())
+
+
+@app.command()
+def init(
+    directory: Annotated[Path, typer.Argument(help="Directory for the new project")],
+    name: Annotated[str, typer.Option(help="Site name")] = "My Sardine CMS",
+    base_url: Annotated[str, typer.Option(help="Canonical base URL")] = "https://example.com",
+    languages: Annotated[
+        str, typer.Option(help="Required target languages, comma-separated")
+    ] = "pt-pt, es, fr, de",
+) -> None:
+    """Scaffold a new project from the built-in Copier template."""
+    from copier import run_copy
+
+    if (directory / PROJECT_FILE).exists():
+        typer.echo(f"error: {directory} already contains {PROJECT_FILE}", err=True)
+        raise typer.Exit(code=2)
+    template = Path(__file__).parent / "templates" / "init"
+    run_copy(
+        str(template),
+        str(directory),
+        data={"project_name": name, "base_url": base_url, "languages": languages},
+        defaults=True,
+        quiet=True,
+    )
+    typer.echo(f"created {directory / PROJECT_FILE} — next: cms seed -p {directory}")
+
+
+@app.command(name="seed")
+def seed_command(
+    project_dir: ProjectDir = Path(),
+    force: Annotated[
+        bool, typer.Option("--force", help="Overwrite content that already exists")
+    ] = False,
+) -> None:
+    """Create fictional starter content in the project storage."""
+    project = _project(project_dir)
+    with project.open_storage() as storage:
+        if storage.has_content() and not force:
+            typer.echo(
+                "error: the project storage already has content; "
+                "seeding would overwrite it (use --force to do so anyway)",
+                err=True,
+            )
+            raise typer.Exit(code=3)
+        pages, articles, media = seed(storage, project.directory)
+    typer.echo(f"seeded {pages} page(s), {articles} article(s) and {media} media asset(s)")
+
+
+@app.command()
+def validate(project_dir: ProjectDir = Path()) -> None:
+    """Run the validation rules; exits non-zero when errors exist."""
+    project = _project(project_dir)
+    report = _validate(project)
+    _report(report)
+    if not report.ok:
+        raise typer.Exit(code=1)
+
+
+def _build_artifact(project: Project) -> Artifact:
+    theme = create_theme(project.site.theme, overrides=project.theme_overrides)
+    return build_site(
+        project.site,
+        project.load_content(),
+        theme=theme,
+        media_files=project.collect_media_files(),
+    )
+
+
+@app.command()
+def build(project_dir: ProjectDir = Path()) -> None:
+    """Validate, then produce the deterministic static build."""
+    project = _project(project_dir)
+    report = _validate(project)
+    if not report.ok:
+        _report(report)
+        raise typer.Exit(code=1)
+    artifact = _build_artifact(project)
+    written = _write_artifact(artifact, project.output)
+    typer.echo(f"built {written} file(s) into {project.output} (digest {artifact.digest()[:12]})")
+
+
+@app.command()
+def export(
+    project_dir: ProjectDir = Path(),
+    target: Annotated[str, typer.Option(help="Deployment target adapter")] = "generic",
+) -> None:
+    """Build plus the deployment target's configuration files."""
+    project = _project(project_dir)
+    report = _validate(project)
+    if not report.ok:
+        _report(report)
+        raise typer.Exit(code=1)
+    artifact = _build_artifact(project)
+    adapter = create_target(target)
+    for path, data in sorted(adapter.extra_files(project.site, artifact).items()):
+        artifact.add(path, data)
+    written = _write_artifact(artifact, project.output)
+    typer.echo(f"exported {written} file(s) for target {adapter.name} into {project.output}")
+
+
+@app.command()
+def preview(
+    project_dir: ProjectDir = Path(),
+    port: Annotated[int, typer.Option(help="Port to serve on")] = 8000,
+) -> None:
+    """Serve the built site locally (build first)."""
+    project = _project(project_dir)
+    if not project.output.is_dir():
+        typer.echo("error: output directory missing — run `cms build` first", err=True)
+        raise typer.Exit(code=2)
+    handler = partial(http.server.SimpleHTTPRequestHandler, directory=str(project.output))
+    typer.echo(f"serving {project.output} at http://127.0.0.1:{port}/ (Ctrl+C to stop)")
+    with http.server.ThreadingHTTPServer(("127.0.0.1", port), handler) as server:
+        server.serve_forever()
+
+
+admin_app = typer.Typer(add_completion=False, no_args_is_help=True)
+app.add_typer(admin_app, name="admin", help="Admin panel operations")
+
+
+@admin_app.command(name="create-user")
+def admin_create_user(
+    username: Annotated[str, typer.Argument(help="Account username (lowercase)")],
+    project_dir: ProjectDir = Path(),
+    role: Annotated[str, typer.Option(help="editor | reviewer | publisher | admin")] = "editor",
+    password: Annotated[
+        str,
+        typer.Option(prompt=True, confirmation_prompt=True, hide_input=True, help="Prompted"),
+    ] = "",
+    force: Annotated[
+        bool, typer.Option("--force", help="Replace the account if it already exists")
+    ] = False,
+) -> None:
+    """Create an admin account (there are no default credentials)."""
+    from datetime import UTC, datetime
+
+    from cms_core.accounts import Role, User
+
+    try:
+        from cms_admin.security import hash_password
+    except ImportError as error:
+        typer.echo("error: the admin package is not installed (pip install cms-admin)", err=True)
+        raise typer.Exit(code=2) from error
+
+    try:
+        account_role = Role(role)
+    except ValueError as error:
+        typer.echo(f"error: unknown role {role!r} (editor|reviewer|publisher|admin)", err=True)
+        raise typer.Exit(code=2) from error
+    project = _project(project_dir)
+    with project.open_storage() as storage:
+        if storage.load_user(username) is not None and not force:
+            typer.echo(f"error: user {username!r} already exists (use --force)", err=True)
+            raise typer.Exit(code=3)
+        storage.save_user(
+            User(
+                username=username,
+                password_hash=hash_password(password),
+                role=account_role,
+                created_at=datetime.now(UTC),
+            )
+        )
+    typer.echo(f"created user {username!r} with role {account_role.value}")
+
+
+def main() -> None:
+    app()

cms_cli/project.py

@@ -0,0 +1,85 @@
+"""Project configuration: `sardine.toml` loading and content access."""
+
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+from cms_build import SiteConfig
+from cms_core import Language
+from cms_core.storage import StorageBackend, create_storage
+from cms_validation import SiteContent
+
+PROJECT_FILE = "sardine.toml"
+LEGACY_PROJECT_FILE = "stillsite.toml"
+"""Pre-rename projects keep working: read the old file when the new one
+is absent (the product was renamed from Stillsite to Sardine CMS)."""
+
+
+@dataclass(frozen=True, slots=True)
+class Project:
+    directory: Path
+    site: SiteConfig
+    storage_url: str
+    output: Path
+
+    def open_storage(self) -> StorageBackend:
+        return create_storage(self.storage_url)
+
+    def load_content(self) -> SiteContent:
+        with self.open_storage() as storage:
+            return SiteContent(
+                articles=storage.load_all_articles(),
+                pages=storage.load_all_pages(),
+                media=storage.load_all_media_assets(),
+            )
+
+    @property
+    def theme_overrides(self) -> Path | None:
+        overrides = self.directory / "theme"
+        return overrides if overrides.is_dir() else None
+
+    def collect_media_files(self) -> dict[str, bytes]:
+        media_dir = self.directory / "media"
+        if not media_dir.is_dir():
+            return {}
+        return {
+            path.relative_to(media_dir).as_posix(): path.read_bytes()
+            for path in sorted(media_dir.rglob("*"))
+            if path.is_file() and not path.name.startswith(".")
+        }
+
+
+def load_project(directory: Path) -> Project:
+    config_path = directory / PROJECT_FILE
+    if not config_path.is_file():
+        legacy = directory / LEGACY_PROJECT_FILE
+        if legacy.is_file():
+            config_path = legacy
+        else:
+            raise FileNotFoundError(f"{PROJECT_FILE} not found in {directory}")
+    data = tomllib.loads(config_path.read_text(encoding="utf-8"))
+
+    site_data = data.get("site", {})
+    site = SiteConfig(
+        name=site_data["name"],
+        base_url=site_data["base_url"],
+        languages=tuple(Language(code) for code in site_data.get("languages", [])),
+        blog_path=site_data.get("blog_path", "blog"),
+        theme=site_data.get("theme", "default"),
+        page_size=site_data.get("page_size", 10),
+        categories=site_data.get("categories", {}),
+        labels=site_data.get("labels", {}),
+        organization=site_data.get("organization"),
+        footer_text=site_data.get("footer_text"),
+        admin_url=site_data.get("admin_url"),
+    )
+
+    storage_url = data.get("storage", {}).get("url", "sqlite:///content.sqlite3")
+    if storage_url.startswith("sqlite:///"):
+        # Relative SQLite paths are relative to the project directory.
+        raw_path = Path(storage_url.removeprefix("sqlite:///").lstrip("/"))
+        resolved = raw_path if raw_path.is_absolute() else directory / raw_path
+        storage_url = f"sqlite:///{resolved}"
+
+    output = directory / data.get("build", {}).get("output", "_site")
+    return Project(directory=directory, site=site, storage_url=storage_url, output=output)

cms_cli/seed.py

@@ -0,0 +1,133 @@
+"""Seed logic: writes the fictional starter content (see seed_data).
+
+Fixed timestamps keep seeded projects building deterministically. When a
+project directory is given, the referenced media files are written too, so a
+freshly scaffolded project builds with no broken references.
+"""
+
+from datetime import timedelta
+from pathlib import Path
+
+from cms_core import (
+    Article,
+    ArticleContent,
+    ContentStatus,
+    Language,
+    MediaAsset,
+    Page,
+    PageContent,
+    Section,
+    SectionContent,
+    new_article,
+    new_page,
+)
+from cms_core.storage import StorageBackend
+
+from cms_cli.seed_data import (
+    ABOUT,
+    ABOUT_STORY,
+    ARTICLES,
+    COVER_ALT,
+    COVER_SVGS,
+    HOME,
+    HOME_ABOUT,
+    HOME_CTA,
+    HOME_EXPERTISE,
+    HOME_HERO,
+    HOME_LATEST,
+    MEDIA_ALT,
+    ROCKET_SVG,
+    SEED_TIME,
+)
+
+
+def _page(
+    page_id: str,
+    contents: dict[Language, PageContent],
+    sections: list[tuple[str, str, dict[Language, SectionContent]]],
+) -> Page:
+    page = new_page(page_id, contents[Language.EN], now=SEED_TIME)
+    for language, content in contents.items():
+        if language is not Language.EN:
+            page.set_translation(language, content)
+    for key, kind, bodies in sections:
+        section = Section(key=key, kind=kind, source=bodies[Language.EN])
+        for language, body in bodies.items():
+            if language is not Language.EN:
+                section.set_translation(language, body)
+        page.sections.append(section)
+    page.status = ContentStatus.PUBLISHED
+    return page
+
+
+def _article(
+    article_id: str,
+    category: str,
+    tags: tuple[str, ...],
+    days: int,
+    contents: dict[Language, ArticleContent],
+) -> Article:
+    article = new_article(article_id, contents[Language.EN], now=SEED_TIME + timedelta(days=days))
+    for language, content in contents.items():
+        if language is not Language.EN:
+            article.set_translation(language, content)
+    article.status = ContentStatus.PUBLISHED
+    article.category = category
+    article.tags = tags
+    return article
+
+
+def seed(storage: StorageBackend, project_dir: Path | None = None) -> tuple[int, int, int]:
+    """Write the starter content; returns (pages, articles, media) counts."""
+    storage.save_page(
+        _page(
+            "home",
+            HOME,
+            [
+                ("hero", "hero", HOME_HERO),
+                ("about", "story", HOME_ABOUT),
+                ("expertise", "expertise", HOME_EXPERTISE),
+                ("latest", "latest-articles", HOME_LATEST),
+                ("join", "contact", HOME_CTA),
+            ],
+        )
+    )
+    storage.save_page(_page("about", ABOUT, [("story", "story", ABOUT_STORY)]))
+
+    for article_id, (category, tags, days, contents) in ARTICLES.items():
+        entry = _article(article_id, category, tags, days, contents)
+        entry.cover = f"cover-{category}"
+        storage.save_article(entry)
+
+    rocket = MediaAsset(
+        id="rocket",
+        path="images/rocket.svg",
+        mime_type="image/svg+xml",
+        width=1200,
+        height=675,
+        alt=dict(MEDIA_ALT),
+    )
+    storage.save_media_asset(rocket)
+    for cover_id, svg in COVER_SVGS.items():
+        storage.save_media_asset(
+            MediaAsset(
+                id=cover_id,
+                path=f"images/{cover_id}.svg",
+                mime_type="image/svg+xml",
+                width=1200,
+                height=630,
+                alt=dict(COVER_ALT[cover_id]),
+            )
+        )
+        if project_dir is not None:
+            cover_target = project_dir / "media" / "images" / f"{cover_id}.svg"
+            cover_target.parent.mkdir(parents=True, exist_ok=True)
+            if not cover_target.exists():
+                cover_target.write_text(svg, encoding="utf-8")
+    if project_dir is not None:
+        target = project_dir / "media" / "images" / "rocket.svg"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if not target.exists():
+            target.write_text(ROCKET_SVG, encoding="utf-8")
+
+    return 2, len(ARTICLES), 1 + len(COVER_SVGS)