code-down 2.0.1__py3-none-any.whl

code_down-2.0.1.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: code-down
+Version: 2.0.1
+Summary: A CLI tool that converts Markdown files into beautifully themed PDFs with syntax-highlighted code blocks.
+Author-email: bouajila <bouajilamedyessine@gmail.com>
+Project-URL: Homepage, https://github.com/bouajilaProg/CodeDown
+Project-URL: Repository, https://github.com/bouajilaProg/CodeDown
+Project-URL: Documentation, https://github.com/bouajilaProg/CodeDown#readme
+Project-URL: Bug Tracker, https://github.com/bouajilaProg/CodeDown/issues
+Keywords: cli,markdown,pdf,converter,documentation
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: markdown>=3.4
+Requires-Dist: pygments>=2.15
+Requires-Dist: weasyprint>=60.0
+Requires-Dist: typer[all]>=0.12.0
+Requires-Dist: click<9.0,>=8.1.7
+Requires-Dist: InquirerPy>=0.3
+Requires-Dist: watchdog>=3.0
+Requires-Dist: requests>=2.28
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+
+# codeDown
+
+[![PyPI version](https://img.shields.io/pypi/v/code-down?color=blue)](https://pypi.org/project/code-down/)
+[![Python](https://img.shields.io/pypi/pyversions/code-down)](https://pypi.org/project/code-down/)
+[![License: MIT](https://img.shields.io/github/license/bouajilaProg/CodeDown)](https://github.com/bouajilaProg/CodeDown/blob/main/LICENSE)
+[![Release](https://img.shields.io/github/actions/workflow/status/bouajilaProg/CodeDown/release.yml?label=release)](https://github.com/bouajilaProg/CodeDown/actions/workflows/release.yml)
+[![GitHub Release](https://img.shields.io/github/v/release/bouajilaProg/CodeDown?label=latest)](https://github.com/bouajilaProg/CodeDown/releases/latest)
+
+**codeDown** is a simple yet powerful **CLI tool** that converts Markdown (`.md`) files into **beautiful themed PDFs** — complete with **syntax-highlighted code blocks**.
+
+Built for developers who love clean documentation, readable code snippets, and automated workflows.
+
+---
+
+## Features
+
+*  **Syntax Highlighting** for code blocks
+*  **Selectable Themes** – interactive picker or CLI flag (`light`, `dark`)
+*  **Watch Mode** – auto-regenerate PDF on file save
+*  **Self-Update** – update from the CLI (`code-down update`)
+*  **Configurable** – set a default theme via `code-down config set-theme`
+*  **Fast & Lightweight** – converts Markdown to PDF in seconds
+
+---
+
+## Installation
+
+### Via pip
+
+```bash
+pip install code-down
+```
+
+### Via binary (Linux)
+
+1. **Download the latest release**
+   Visit the [Releases Page](https://github.com/bouajilaProg/CodeDown/releases) and download the latest Linux binary.
+
+2. **Make it executable and move to PATH**
+
+   ```bash
+   chmod +x code-down
+   sudo mv code-down /usr/local/bin/
+   ```
+
+---
+
+## Usage
+
+Convert a Markdown file into a themed PDF:
+
+```bash
+code-down input.md output.pdf -s dark
+```
+
+### Watch mode
+
+Automatically rebuild the PDF when the Markdown file changes:
+
+```bash
+code-down -w input.md
+```
+
+### Options
+
+| Flag              | Description                             | Default                             |
+| ----------------- | --------------------------------------- | ----------------------------------- |
+| `-o, --output`    | Output PDF file path                    | Same as input with `.pdf` extension |
+| `-s, --style`     | Theme style (e.g. `light`, `dark`)      | Config default or `dark`            |
+| `-w, --watch`     | Watch file and rebuild PDF on changes   |                                     |
+| `-v, --version`   | Print version and exit                  |                                     |
+
+### Commands
+
+| Command              | Description                                   |
+| -------------------- | --------------------------------------------- |
+| `code-down themes`   | Pick a theme interactively (sets as default)   |
+| `code-down config show` | Show current configuration                 |
+| `code-down config set-theme` | Set the default theme (interactive or by name) |
+| `code-down update`   | Update codeDown to the latest version          |
+
+### Examples
+
+Quick test file:
+
+```bash
+code-down examples/example.md
+```
+
+Convert `README.md` to `README.pdf` using the default theme:
+
+```bash
+code-down README.md
+```
+
+Convert with a dark theme and custom output name:
+
+```bash
+code-down README.md -o README_dark.pdf -s dark
+```
+
+Watch a file and rebuild on every save:
+
+```bash
+code-down -w notes.md -s light
+```
+
+Pick a theme interactively:
+
+```bash
+code-down themes
+```
+
+---
+
+## Notes
+
+* Ensure your Markdown files are UTF-8 encoded for best results.
+* Supports syntax highlighting for most major programming languages.
+* Works completely offline — no internet connection required (except for `update`).

code_down-2.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+codedown/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codedown/__main__.py,sha256=UeAguGS48NLruFMyP1aeXPLorjXtSieGfWPUgOa1B68,981
+codedown/cli.py,sha256=T-JSP-yvMRD05yrDCPyxaw2CszSGBZYZj4oWFtJwRd4,7394
+codedown/config.py,sha256=THil9juWAXTNdjYRMnYZOjcg4Gqc0VzuGdnTdhfV8Is,1221
+codedown/converter.py,sha256=D0IN39ka2HPCngS-ewRQx7U2enlw8kLgrNuAlLJjm_E,1271
+codedown/paths.py,sha256=EriJ7feYBy0k-BVxV2uYKFwfmGaP_v45BWi3XULYkDg,146
+codedown/themes.py,sha256=3bLs4BWHzppDNQAePHkpLl9OoPM7nFeZGw6rDHb7IfE,1685
+codedown/updater.py,sha256=37qLZNOE8hpVr-eNm82dyV4CqAQK9dId6mH3KO7Ivno,3871
+codedown/watcher.py,sha256=llSCn_E_9c9Xs2z2sXfkkn0VhUMNT0_I2Q620fDwAas,1960
+codedown/assets/themes/base.css,sha256=cf_PaOSqSVmVgpjwN94x3T4BY8VFfqUAmuszVbkaCa8,2076
+codedown/assets/themes/dark.css,sha256=W9NSkSe7EXJrHDrNvq8U7uGWgp2n4jGKeSJkgLXzwMw,615
+codedown/assets/themes/dark.toml,sha256=6oAD0aaNsVLloav2OPkcc7QuGmB-7o_P1WmYPUndeik,77
+codedown/assets/themes/light.css,sha256=BGtxeo-7kArASR5rjewX3E7EPOSfmwCqJRgzIByef9w,646
+codedown/assets/themes/light.toml,sha256=mlKb4gDkSTUFSaKIKLR6trGRdvTy_isjFJM0s4GO67c,79
+code_down-2.0.1.dist-info/METADATA,sha256=WDq9j0PJMJUnmaLELzHINl1a5gFcI5sl55lWGyKt6PY,4877
+code_down-2.0.1.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+code_down-2.0.1.dist-info/entry_points.txt,sha256=VV12-3wgXOTMrNrhsBMM4BdCZl7X8k9CtJ90b_l4Qvg,53
+code_down-2.0.1.dist-info/top_level.txt,sha256=rE1C2xNDH3XWkaQrHsvrpIOE_CwBl0aPe9xpD-f2Tsg,9
+code_down-2.0.1.dist-info/RECORD,,

code_down-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

code_down-2.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+code-down = codedown.__main__:main

code_down-2.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+codedown

codedown/__main__.py

@@ -0,0 +1,41 @@
+import sys
+from pathlib import Path
+
+from codedown.cli import app
+
+
+_SUBCOMMANDS = {"convert", "config", "themes", "update"}
+_CONVERT_LEADING_OPTIONS = {"-w", "--watch", "-s", "--style", "-o", "--output"}
+
+
+def _rewrite_argv_for_implicit_convert(argv: list[str]) -> list[str]:
+    if len(argv) < 2:
+        return argv
+
+    first = argv[1]
+
+    # Let click/typer handle help/version and explicit subcommands.
+    if first in {"-h", "--help", "-v", "--version"}:
+        return argv
+    if first in _SUBCOMMANDS:
+        return argv
+
+    # Support: code-down -w file.md  (and -s/-o before the file)
+    if first in _CONVERT_LEADING_OPTIONS:
+        return [argv[0], "convert", *argv[1:]]
+
+    # Support: code-down file.md
+    p = Path(first)
+    if p.exists() or first.lower().endswith(".md"):
+        return [argv[0], "convert", *argv[1:]]
+
+    return argv
+
+
+def main():
+    sys.argv = _rewrite_argv_for_implicit_convert(sys.argv)
+    app()
+
+
+if __name__ == "__main__":
+    main()

codedown/assets/themes/base.css

@@ -0,0 +1,132 @@
+html,
+body {
+  margin: 0;
+  padding: 0;
+  background-color: var(--theme-bg);
+  color: var(--theme-text);
+  font-family: "Fira Code", "JetBrains Mono", Consolas, monospace;
+  line-height: 1.6;
+  font-size: 16px;
+  padding-left: 20px;
+  padding-right: 20px;
+  box-sizing: border-box;
+}
+
+body {
+  padding-top: 10px;
+  padding-bottom: 10px;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  color: var(--theme-header);
+  border-bottom: 1px solid var(--theme-border);
+  padding-bottom: 0.2em;
+}
+
+a {
+  color: var(--theme-link);
+  text-decoration: underline;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+pre,
+code {
+  font-family: "Fira Code", "JetBrains Mono", Consolas, monospace;
+}
+
+pre {
+  background-color: var(--theme-code-bg);
+  padding: 12px 16px;
+  border-radius: 8px;
+  overflow-x: auto;
+  color: var(--theme-text);
+  box-shadow: 0 0 10px var(--theme-code-shadow);
+  white-space: pre-wrap;
+  word-wrap: break-word;
+}
+
+blockquote {
+  border-left: 4px solid var(--theme-blockquote-border);
+  margin: 1em 0;
+  padding-left: 1em;
+  color: var(--theme-blockquote-text);
+  background-color: var(--theme-blockquote-bg);
+}
+
+hr {
+  border: none;
+  border-top: 1px solid var(--theme-hr-border);
+  margin: 2em 0;
+}
+
+img {
+  max-width: 100%;
+  border-radius: 6px;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 1em 0;
+}
+
+th,
+td {
+  border: 1px solid var(--theme-hr-border);
+  padding: 8px 12px;
+  text-align: left;
+}
+
+th {
+  background-color: var(--theme-table-header-bg);
+  color: var(--theme-table-header-text);
+}
+
+@media print {
+  @page {
+    size: auto;
+    margin: 20px;
+    background-color: var(--theme-bg);
+  }
+
+  html,
+  body {
+    background-color: var(--theme-bg);
+    -webkit-print-color-adjust: exact;
+    print-color-adjust: exact;
+    padding-left: 20px;
+    padding-right: 20px;
+    padding-top: 10px;
+    padding-bottom: 10px;
+  }
+
+  pre,
+  img,
+  table,
+  blockquote {
+    page-break-inside: avoid;
+    break-inside: avoid;
+  }
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6 {
+    page-break-after: avoid;
+    break-after: avoid;
+  }
+
+  tr {
+    page-break-inside: avoid;
+  }
+}

codedown/assets/themes/dark.css

@@ -0,0 +1,27 @@
+/* Dark Theme Variables (Tokyonight-inspired) */
+:root {
+  /* Core Colors */
+  --theme-bg: #1a1b26;
+  --theme-text: #c0caf5;
+
+  /* Accent Colors */
+  --theme-header: #7aa2f7;
+  --theme-link: #7dcfff;
+
+  /* Structural Colors */
+  --theme-border: #2f3549;
+  --theme-hr-border: #3b4261;
+
+  /* Code Block Colors */
+  --theme-code-bg: #24283b;
+  --theme-code-shadow: rgba(0, 0, 0, 0.3);
+
+  /* Blockquote Colors */
+  --theme-blockquote-bg: #1f2335;
+  --theme-blockquote-border: #565f89;
+  --theme-blockquote-text: #a9b1d6;
+
+  /* Table Colors */
+  --theme-table-header-bg: #2f3549;
+  --theme-table-header-text: #bb9af7;
+}

codedown/assets/themes/dark.toml

@@ -0,0 +1,4 @@
+name = "dark"
+css_file = "dark.css"
+code_theme = "monokai"
+version = "1.0.0"

codedown/assets/themes/light.css

@@ -0,0 +1,28 @@
+/* Light Theme Variables (High-Contrast) */
+:root {
+  /* Core Colors */
+  --theme-bg: #f9f9f9;
+  --theme-text: #333333;
+
+  /* Accent Colors */
+  --theme-header: #007acc;
+  --theme-link: #005f99;
+
+  /* Structural Colors */
+  --theme-border: #cccccc;
+  --theme-hr-border: #bbbbbb;
+
+  /* Code Block Colors */
+  --theme-code-bg: #eeeeee;
+  --theme-code-shadow: rgba(0, 0, 0, 0.1);
+
+  /* Blockquote Colors */
+  --theme-blockquote-bg: #f0f8ff;
+  --theme-blockquote-border: #7db0e5;
+  --theme-blockquote-text: #444444;
+  /* Darker text for readability */
+
+  /* Table Colors */
+  --theme-table-header-bg: #e0e0e0;
+  --theme-table-header-text: #444444;
+}

codedown/assets/themes/light.toml

@@ -0,0 +1,4 @@
+name = "light"
+css_file = "light.css"
+code_theme = "default"
+version = "1.0.0"

codedown/cli.py

@@ -0,0 +1,266 @@
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+
+def _get_package_version() -> str:
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+
+        return version("code-down")
+    except Exception:
+        return "unknown"
+
+
+def _version_callback(value: bool):
+    if not value:
+        return
+    typer.echo(_get_package_version())
+    raise typer.Exit(0)
+
+
+app = typer.Typer(
+    name="code-down",
+    help="Convert Markdown files into beautifully themed PDFs with syntax-highlighted code blocks.",
+    add_completion=False,
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+config_app = typer.Typer(
+    help="Manage codeDown configuration.",
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+app.add_typer(config_app, name="config")
+
+
+@app.callback()
+def _global_options(
+    version: bool = typer.Option(
+        False,
+        "-v",
+        "--version",
+        help="Show version and exit",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+):
+    return
+
+
+def _resolve_output_file(
+    input_file: Path,
+    output_arg: Optional[Path],
+    output_opt: Optional[Path],
+) -> Path:
+    if output_arg is not None and output_opt is not None:
+        typer.echo(
+            "Error: provide output either as 2nd argument or via -o/--output", err=True
+        )
+        raise typer.Exit(code=2)
+
+    output_raw = output_opt or output_arg
+    if output_raw is None:
+        return input_file.with_suffix(".pdf")
+
+    # Treat as directory if it is a dir, or has no suffix (e.g. `temp`).
+    if output_raw.exists() and output_raw.is_dir():
+        output_dir = output_raw
+        output_dir.mkdir(parents=True, exist_ok=True)
+        return output_dir / f"{input_file.stem}.pdf"
+
+    if output_raw.suffix == "":
+        output_dir = output_raw
+        output_dir.mkdir(parents=True, exist_ok=True)
+        return output_dir / f"{input_file.stem}.pdf"
+
+    if output_raw.suffix.lower() != ".pdf":
+        output_raw = output_raw.with_suffix(".pdf")
+
+    output_raw.parent.mkdir(parents=True, exist_ok=True)
+    return output_raw
+
+
+def _theme_choice_values(current: str) -> list[str]:
+    from codedown.themes import get_all_themes
+
+    names = sorted({t.name for t in get_all_themes()}, key=str.lower)
+    if current in names:
+        names.remove(current)
+        return [current, *names]
+    return names
+
+
+@app.command("convert")
+def convert_command(
+    input_file: Path = typer.Argument(..., help="Input Markdown file to convert"),
+    output_location: Optional[Path] = typer.Argument(
+        None, help="Output directory or PDF path (optional)"
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "-o", "--output", help="Output PDF file path"
+    ),
+    style: Optional[str] = typer.Option(
+        None, "-s", "--style", help="Theme style (e.g. light, dark)"
+    ),
+    watch: bool = typer.Option(
+        False, "-w", "--watch", help="Watch the file and rebuild PDF on changes"
+    ),
+):
+    """Convert a Markdown file into a themed PDF."""
+    if watch:
+        _do_watch(input_file, output_location, output, style)
+    else:
+        _do_convert(input_file, output_location, output, style)
+
+
+def _do_convert(
+    input_file: Path,
+    output_location: Optional[Path] = None,
+    output_opt: Optional[Path] = None,
+    style: Optional[str] = None,
+):
+    """Core conversion logic shared by convert and watch."""
+    from codedown.config import load_config
+    from codedown.converter import ConverterEngine
+
+    if not input_file.exists():
+        typer.echo(f"Error: Input file '{input_file}' does not exist", err=True)
+        raise typer.Exit(code=1)
+
+    output_file = _resolve_output_file(input_file, output_location, output_opt)
+    config = load_config()
+    theme_name = style or config.get("default_theme", "dark")
+
+    markdown_text = input_file.read_text(encoding="utf-8")
+    converter = ConverterEngine(markdown_text)
+    converter.convert_to_pdf(str(output_file), style=theme_name)
+
+    typer.echo(f"PDF successfully created: {output_file}")
+
+
+def _do_watch(
+    input_file: Path,
+    output_location: Optional[Path] = None,
+    output_opt: Optional[Path] = None,
+    style: Optional[str] = None,
+):
+    """Watch the input file and rebuild PDF on changes."""
+    from codedown.config import load_config
+    from codedown.watcher import watch_and_convert
+
+    if not input_file.exists():
+        typer.echo(f"Error: Input file '{input_file}' does not exist", err=True)
+        raise typer.Exit(code=1)
+
+    output_file = _resolve_output_file(input_file, output_location, output_opt)
+    config = load_config()
+    theme_name = style or config.get("default_theme", "dark")
+
+    watch_and_convert(input_file, output_file, theme_name)
+
+
+# --- config subcommands ---
+
+
+@config_app.command("show")
+def config_show():
+    """Show current configuration."""
+    from codedown.config import CONFIG_FILE, load_config
+
+    config = load_config()
+    if not config:
+        typer.echo("No configuration set. Using defaults.")
+        typer.echo(f"  Config file: {CONFIG_FILE}")
+        typer.echo(f"  default_theme = dark")
+        return
+
+    typer.echo(f"Config file: {CONFIG_FILE}")
+    for key, value in config.items():
+        typer.echo(f"  {key} = {value}")
+
+
+@config_app.command("set-theme")
+def config_set_theme(
+    theme_name: Optional[str] = typer.Argument(
+        None, help="Theme name to set as default"
+    ),
+):
+    """Set the default theme. Run without arguments for interactive picker."""
+    from codedown.config import set_default_theme
+    from codedown.themes import get_theme_by_name
+
+    if theme_name is None:
+        _pick_and_set_theme()
+        return
+
+    # Validate the theme exists
+    get_theme_by_name(theme_name)
+    set_default_theme(theme_name)
+    typer.echo(f"Default theme set to '{theme_name}'")
+
+
+def _pick_and_set_theme():
+    """Interactive theme picker using InquirerPy."""
+    from InquirerPy import inquirer
+
+    from codedown.config import get_default_theme, set_default_theme
+
+    current = get_default_theme()
+    theme_names = _theme_choice_values(current)
+
+    choices = [{"name": name, "value": name} for name in theme_names]
+
+    selected = inquirer.select(
+        message="Select default theme:",
+        choices=choices,
+        default=current,
+    ).execute()
+
+    if selected is None:
+        typer.echo("Cancelled.")
+        raise typer.Exit(0)
+
+    set_default_theme(selected)
+    typer.echo(f"Default theme set to '{selected}'")
+
+
+# --- themes command ---
+
+
+@app.command("themes")
+def themes_command():
+    """Browse and select a theme interactively."""
+    from InquirerPy import inquirer
+
+    from codedown.config import get_default_theme, set_default_theme
+
+    current = get_default_theme()
+    theme_names = _theme_choice_values(current)
+
+    choices = [{"name": name, "value": name} for name in theme_names]
+
+    selected = inquirer.select(
+        message="Pick a theme:",
+        choices=choices,
+        default=current,
+    ).execute()
+
+    if selected is None:
+        raise typer.Exit(0)
+
+    set_default_theme(selected)
+    typer.echo(f"Default theme set to '{selected}'")
+
+
+# --- update command ---
+
+
+@app.command("update")
+def update_command():
+    """Update codeDown to the latest version."""
+    from codedown.updater import run_update
+
+    run_update()

codedown/config.py

@@ -0,0 +1,48 @@
+import sys
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomllib
+    except ImportError:
+        import tomli as tomllib
+
+CONFIG_DIR = Path.home() / ".config" / "codedown"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+def load_config() -> dict:
+    if not CONFIG_FILE.exists():
+        return {}
+    with open(CONFIG_FILE, "rb") as f:
+        return tomllib.load(f)
+
+
+def save_config(config: dict) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    lines = []
+    for key, value in config.items():
+        if isinstance(value, str):
+            lines.append(f'{key} = "{value}"')
+        elif isinstance(value, bool):
+            lines.append(f"{key} = {'true' if value else 'false'}")
+        elif isinstance(value, int):
+            lines.append(f"{key} = {value}")
+        else:
+            lines.append(f'{key} = "{value}"')
+
+    CONFIG_FILE.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def get_default_theme() -> str:
+    config = load_config()
+    return config.get("default_theme", "dark")
+
+
+def set_default_theme(theme_name: str) -> None:
+    config = load_config()
+    config["default_theme"] = theme_name
+    save_config(config)

codedown/converter.py

@@ -0,0 +1,36 @@
+from codedown.themes import Theme, get_theme_by_name
+
+
+class ConverterEngine:
+    def __init__(self, markdown_text: str):
+        self.markdown_text = markdown_text
+
+    def convert_to_html(self) -> str:
+        import markdown
+        from markdown.extensions.codehilite import CodeHiliteExtension
+        from markdown.extensions.tables import TableExtension
+
+        html = markdown.markdown(
+            self.markdown_text,
+            extensions=[
+                "fenced_code",
+                CodeHiliteExtension(linenums=False, css_class="highlight"),
+                TableExtension(),
+            ],
+        )
+        return html
+
+    def apply_theme(self, html_content: str, theme: Theme) -> str:
+        return f"""<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">
+                    <title>Markdown Preview</title><style>{theme.get_css()}
+                    </style></head>
+                    <body>{html_content}</body></html>"""
+
+    def convert_to_pdf(self, output_pdf_path: str, style: str = "dark"):
+        from weasyprint import HTML
+
+        html_content = self.convert_to_html()
+        theme = get_theme_by_name(style)
+        full_html = self.apply_theme(html_content, theme)
+
+        HTML(string=full_html).write_pdf(output_pdf_path)

codedown/paths.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent
+ASSETS_DIR = BASE_DIR / "assets"
+THEMES_DIR = BASE_DIR / "assets" / "themes"

codedown/themes.py

@@ -0,0 +1,67 @@
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from pygments.formatters import HtmlFormatter
+
+from codedown.paths import THEMES_DIR
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomllib
+    except ImportError:
+        import tomli as tomllib
+
+
+@dataclass
+class Theme:
+    name: str
+    css_file: str
+    code_theme: str
+    version: str
+
+    def get_css(self) -> str:
+        css = ""
+
+        theme_path = THEMES_DIR / self.css_file
+        if theme_path.exists():
+            css += "\n" + theme_path.read_text(encoding="utf-8")
+
+        css = HtmlFormatter(style=self.code_theme).get_style_defs(".highlight") + css
+
+        base_theme_path = THEMES_DIR / "base.css"
+        if base_theme_path.exists():
+            css += "\n" + base_theme_path.read_text(encoding="utf-8")
+
+        return css
+
+    @classmethod
+    def from_toml(cls, path: Path) -> "Theme":
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+        return cls(
+            name=data["name"],
+            css_file=data["css_file"],
+            code_theme=data["code_theme"],
+            version=data.get("version", "1.0.0"),
+        )
+
+
+def get_all_themes() -> list[Theme]:
+    themes = []
+    for toml_file in sorted(THEMES_DIR.glob("*.toml")):
+        themes.append(Theme.from_toml(toml_file))
+    return themes
+
+
+def get_theme_by_name(name: str) -> Theme:
+    name = name.strip().lower()
+    for theme in get_all_themes():
+        if theme.name.lower() == name:
+            return theme
+
+    available = ", ".join(t.name for t in get_all_themes())
+    print(f"Error: Unknown theme '{name}'. Available: {available}")
+    sys.exit(1)

codedown/updater.py

@@ -0,0 +1,135 @@
+import os
+import platform
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+
+import requests
+import typer
+
+GITHUB_REPO = "bouajilaProg/CodeDown"
+GITHUB_API_URL = f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest"
+PYPI_PACKAGE_NAME = "code-down"
+
+
+def get_current_version() -> str:
+    from importlib.metadata import version
+
+    try:
+        return version(PYPI_PACKAGE_NAME)
+    except Exception:
+        return "unknown"
+
+
+def is_pyinstaller_bundle() -> bool:
+    return getattr(sys, "_MEIPASS", None) is not None
+
+
+def get_latest_github_release() -> dict:
+    response = requests.get(GITHUB_API_URL, timeout=15)
+    response.raise_for_status()
+    return response.json()
+
+
+def update_via_pip():
+    """Update using pip install --upgrade."""
+    current = get_current_version()
+    typer.echo(f"Current version: {current}")
+    typer.echo("Checking PyPI for updates...")
+
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "install", "--upgrade", PYPI_PACKAGE_NAME],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        typer.echo(f"Error updating via pip:\n{result.stderr}", err=True)
+        raise typer.Exit(code=1)
+
+    new_version = get_current_version()
+    if new_version == current:
+        typer.echo("Already up to date.")
+    else:
+        typer.echo(f"Updated: {current} → {new_version}")
+
+
+def update_via_binary():
+    """Update the standalone binary from GitHub Releases."""
+    current = get_current_version()
+    typer.echo(f"Current version: {current}")
+    typer.echo("Checking GitHub Releases for updates...")
+
+    try:
+        release = get_latest_github_release()
+    except Exception as e:
+        typer.echo(f"Error fetching release info: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    tag = release.get("tag_name", "unknown")
+    typer.echo(f"Latest release: {tag}")
+
+    # Find the Linux binary asset
+    system = platform.system().lower()
+    asset = None
+    for a in release.get("assets", []):
+        name = a["name"].lower()
+        if system in name or "code-down" in name:
+            asset = a
+            break
+
+    if asset is None:
+        typer.echo(
+            f"No binary found for {system} in release {tag}. "
+            "Try updating via pip: pip install --upgrade code-down",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Downloading {asset['name']}...")
+
+    response = requests.get(asset["browser_download_url"], stream=True, timeout=60)
+    response.raise_for_status()
+
+    current_exe = os.path.realpath(sys.executable)
+    if is_pyinstaller_bundle():
+        current_exe = os.path.realpath(sys.argv[0])
+
+    # Write to a temp file, then replace the current binary
+    fd, tmp_path = tempfile.mkstemp(prefix="code-down-update-")
+    try:
+        with os.fdopen(fd, "wb") as tmp:
+            for chunk in response.iter_content(chunk_size=8192):
+                tmp.write(chunk)
+
+        # Make executable
+        os.chmod(tmp_path, os.stat(tmp_path).st_mode | stat.S_IEXEC)
+
+        # Replace the current binary
+        shutil.move(tmp_path, current_exe)
+        typer.echo(f"Updated binary at {current_exe}")
+    except PermissionError:
+        typer.echo(
+            f"Permission denied. Try: sudo code-down update",
+            err=True,
+        )
+        # Clean up temp file
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        raise typer.Exit(code=1)
+    except Exception:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        raise
+
+
+def run_update():
+    """Auto-detect installation method and update accordingly."""
+    if is_pyinstaller_bundle():
+        typer.echo("Detected: standalone binary (PyInstaller)")
+        update_via_binary()
+    else:
+        typer.echo("Detected: pip-installed package")
+        update_via_pip()

codedown/watcher.py

@@ -0,0 +1,69 @@
+import time
+from pathlib import Path
+from typing import Callable
+
+import typer
+from watchdog.events import FileModifiedEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+
+class _MarkdownHandler(FileSystemEventHandler):
+    def __init__(self, target_file: Path, on_change: Callable[[], None]):
+        super().__init__()
+        self.target_file = target_file.resolve()
+        self.on_change = on_change
+        self._last_trigger = 0.0
+
+    def on_modified(self, event):
+        if event.is_directory:
+            return
+
+        if Path(event.src_path).resolve() != self.target_file:
+            return
+
+        # Debounce: ignore events within 1 second of each other
+        now = time.time()
+        if now - self._last_trigger < 1.0:
+            return
+        self._last_trigger = now
+
+        self.on_change()
+
+
+def watch_and_convert(
+    input_file: Path,
+    output_file: Path,
+    style: str,
+):
+    """Watch a Markdown file and regenerate the PDF on every change."""
+    from codedown.converter import ConverterEngine
+
+    input_file = input_file.resolve()
+    watch_dir = input_file.parent
+
+    def rebuild():
+        try:
+            markdown_text = input_file.read_text(encoding="utf-8")
+            converter = ConverterEngine(markdown_text)
+            converter.convert_to_pdf(str(output_file), style=style)
+            typer.echo(f"[watch] Rebuilt: {output_file}")
+        except Exception as e:
+            typer.echo(f"[watch] Error: {e}", err=True)
+
+    # Initial build
+    rebuild()
+    typer.echo(f"[watch] Watching {input_file} for changes... (Ctrl+C to stop)")
+
+    handler = _MarkdownHandler(input_file, rebuild)
+    observer = Observer()
+    observer.schedule(handler, str(watch_dir), recursive=False)
+    observer.start()
+
+    try:
+        while True:
+            time.sleep(0.5)
+    except KeyboardInterrupt:
+        typer.echo("\n[watch] Stopped.")
+    finally:
+        observer.stop()
+        observer.join()