latex-forge 0.2.0__py3-none-any.whl

latex_forge/.vscode/extensions.json

@@ -0,0 +1,9 @@
+{
+  "recommendations": [
+    "James-Yu.latex-workshop",
+    "ltex-plus.vscode-ltex-plus",
+    "streetsidesoftware.code-spell-checker",
+    "streetsidesoftware.code-spell-checker-french",
+    "MS-vsliveshare.vsliveshare"
+  ]
+}

latex_forge/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

latex_forge/assets/images/common/README.md

@@ -0,0 +1,8 @@
+Place ici les PNG, JPG ou PDF que tu reutilises dans plusieurs projets.
+
+Exemples :
+
+- schemas generiques
+- captures d'ecran recurrentes
+- signatures visuelles
+- icones maison

latex_forge/assets/logos/README.md

@@ -0,0 +1,8 @@
+Place ici les logos reutilises entre plusieurs documents.
+
+Exemples :
+
+- logo labo
+- logo entreprise
+- logo universite
+- logo-up-maths-info.jpg pour le template TER IAD/VMI

latex_forge/cli.py

@@ -0,0 +1,423 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+import argcomplete
+
+from .config import get_default_output_dir, get_default_template
+from .project import (
+    TEMPLATE_DESCRIPTIONS,
+    available_templates,
+    create_project,
+    rename_current_project,
+    rename_project,
+    templates_dir,
+    validate_name,
+)
+from .setup import (
+    is_first_run,
+    mark_initialized,
+    offer_open_vscode,
+    run_first_launch_check,
+    run_profile_setup,
+    run_setup,
+    warn_if_latex_missing,
+)
+
+
+def _get_version() -> str:
+    try:
+        return version("latex-forge")
+    except PackageNotFoundError:
+        return "unknown"
+
+
+def _is_interactive() -> bool:
+    try:
+        return sys.stdin.isatty()
+    except Exception:
+        return False
+
+
+def _ask_project_name() -> str:
+    while True:
+        try:
+            name = input("Project name: ").strip()
+        except (EOFError, OSError, KeyboardInterrupt):
+            print("")
+            sys.exit(1)
+        try:
+            validate_name(name)
+            return name
+        except ValueError as exc:
+            print(str(exc))
+
+
+def _select_template_interactively() -> str:
+    templates = available_templates()
+    width = max(len(t) for t in templates)
+    print("Available templates:")
+    for i, t in enumerate(templates, 1):
+        desc = TEMPLATE_DESCRIPTIONS.get(t, "")
+        suffix = f"  {desc}" if desc else ""
+        print(f"  {i}. {t:<{width}}{suffix}")
+    while True:
+        try:
+            answer = input(f"Choose a template [1-{len(templates)}]: ").strip()
+            idx = int(answer) - 1
+            if 0 <= idx < len(templates):
+                return templates[idx]
+        except (EOFError, OSError, KeyboardInterrupt):
+            print("")
+            sys.exit(1)
+        except ValueError:
+            pass
+        print(f"Please enter a number between 1 and {len(templates)}.")
+
+
+def _ask_output_dir() -> Path:
+    config_dir = get_default_output_dir()
+    default = config_dir if config_dir is not None else Path.cwd()
+    try:
+        answer = input(f"Create project in [{default}]: ").strip()
+    except (EOFError, OSError, KeyboardInterrupt):
+        print("")
+        sys.exit(1)
+    if not answer:
+        return default
+    path = Path(answer).expanduser().resolve()
+    if not path.exists():
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+        except OSError as exc:
+            print(f"Cannot create directory: {exc}", file=sys.stderr)
+            sys.exit(1)
+    return path
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="latex-forge",
+        description="Utilities for generating standalone LaTeX projects from the toolbox.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {_get_version()}",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    create_parser = subparsers.add_parser(
+        "create",
+        help="Create a new LaTeX project from a template.",
+    )
+    create_parser.add_argument(
+        "--name",
+        default=None,
+        help="Name of the project (prompted interactively if omitted).",
+    )
+    template_arg = create_parser.add_argument(
+        "--template",
+        default=None,
+        help="Template name to use (prompted interactively if omitted).",
+    )
+    template_arg.completer = lambda **kwargs: available_templates()
+    create_parser.add_argument(
+        "--output",
+        default=None,
+        help="Directory where the project will be created (default: current directory).",
+    )
+
+    rename_parser = subparsers.add_parser(
+        "rename",
+        help="Rename a generated LaTeX project folder and its main .tex file.",
+    )
+    rename_parser.add_argument(
+        "names",
+        nargs="+",
+        help="Use `old_name new_name` from the parent folder, or only `new_name` from inside the project folder.",
+    )
+
+    setup_parser = subparsers.add_parser(
+        "setup",
+        help="Install VS Code extensions when possible and check LaTeX prerequisites.",
+    )
+    setup_parser.add_argument(
+        "--check-only",
+        action="store_true",
+        help="Only check the current environment without installing VS Code extensions.",
+    )
+    setup_parser.add_argument(
+        "--skip-extensions",
+        action="store_true",
+        help="Skip VS Code extension installation.",
+    )
+    setup_parser.add_argument(
+        "--install-tex",
+        action="store_true",
+        help="Try to install a LaTeX distribution with a common package manager for the current OS.",
+    )
+
+    subparsers.add_parser(
+        "list-templates",
+        help="List the available templates.",
+    )
+
+    profile_parser = subparsers.add_parser(
+        "profile",
+        help="View or update your profile used to pre-fill project metadata.",
+    )
+    profile_parser.add_argument(
+        "--set",
+        action="store_true",
+        help="Run interactive profile setup.",
+    )
+
+    template_parser = subparsers.add_parser(
+        "template",
+        help="Install, remove or list templates.",
+    )
+    template_sub = template_parser.add_subparsers(dest="template_command", required=True)
+
+    t_install = template_sub.add_parser(
+        "install",
+        help="Install a template from a GitHub URL, ZIP URL, or local path.",
+    )
+    t_install.add_argument(
+        "source",
+        help="GitHub URL, ZIP URL, local directory, or local .zip file.",
+    )
+    t_install.add_argument(
+        "--name",
+        default=None,
+        help="Name to give the installed template (defaults to repo/folder name).",
+    )
+
+    template_sub.add_parser(
+        "list",
+        help="List built-in and user-installed templates.",
+    )
+
+    t_remove = template_sub.add_parser(
+        "remove",
+        help="Remove a user-installed template.",
+    )
+    t_remove.add_argument("name", help="Name of the template to remove.")
+
+    completion_parser = subparsers.add_parser(
+        "completion",
+        help="Print shell completion setup code.",
+    )
+    completion_parser.add_argument(
+        "--shell",
+        choices=["bash", "zsh", "fish"],
+        default=None,
+        help="Shell type (auto-detected from $SHELL if omitted).",
+    )
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args(argv)
+
+    if args.command == "template":
+        from .template_manager import install_template, list_user_templates, remove_template
+
+        if args.template_command == "install":
+            try:
+                name, path = install_template(args.source, args.name)
+            except (ValueError, FileNotFoundError, OSError) as exc:
+                print(str(exc), file=sys.stderr)
+                return 1
+            print(f"Template installed: {name}")
+            print(f"Location: {path}")
+            print(f"Use it with: latex-forge create --template {name}")
+            return 0
+
+        if args.template_command == "list":
+            built_in = sorted(p.name for p in templates_dir().iterdir() if p.is_dir())
+            user = list_user_templates()
+            width = max((len(t) for t in built_in + user), default=0)
+            print("Built-in templates:")
+            for t in built_in:
+                desc = TEMPLATE_DESCRIPTIONS.get(t, "")
+                suffix = f"  {desc}" if desc else ""
+                print(f"  {t:<{width}}{suffix}")
+            if user:
+                print("\nInstalled templates:")
+                for t in user:
+                    print(f"  {t}")
+            else:
+                print("\nNo user-installed templates.")
+                print("Install one with: latex-forge template install <url-or-path>")
+            return 0
+
+        if args.template_command == "remove":
+            try:
+                remove_template(args.name)
+            except (ValueError, FileNotFoundError) as exc:
+                print(str(exc), file=sys.stderr)
+                return 1
+            print(f"Template removed: {args.name}")
+            return 0
+
+    if args.command == "list-templates":
+        templates = available_templates()
+        width = max(len(t) for t in templates)
+        for t in templates:
+            desc = TEMPLATE_DESCRIPTIONS.get(t, "")
+            if desc:
+                print(f"  {t:<{width}}  {desc}")
+            else:
+                print(f"  {t}")
+        return 0
+
+    if args.command == "profile":
+        if args.set:
+            run_profile_setup()
+            return 0
+
+        from .config import get_profile
+        profile = get_profile()
+        if not profile:
+            print("No profile configured.")
+            print("Run `latex-forge profile --set` to set up your profile.")
+            return 0
+
+        print("Profile:")
+        for key, label in [
+            ("name", "Name"),
+            ("university", "University"),
+            ("program", "Program"),
+            ("github", "GitHub"),
+        ]:
+            value = profile.get(key)
+            if value:
+                display = f"github.com/{value}" if key == "github" else value
+                print(f"  {label:<12} {display}")
+        return 0
+
+    if args.command == "completion":
+        shell = args.shell
+        if shell is None:
+            shell_path = os.environ.get("SHELL", "")
+            shell = Path(shell_path).name if shell_path else "bash"
+            if shell not in ("bash", "zsh", "fish"):
+                shell = "bash"
+        print(argcomplete.shellcode(["latex-forge"], shell=shell))
+        return 0
+
+    if args.command == "create":
+        name = args.name
+        template = args.template
+        guided = False
+
+        if name is None:
+            if not _is_interactive():
+                print("--name is required in non-interactive mode.", file=sys.stderr)
+                return 1
+            name = _ask_project_name()
+            guided = True
+
+        if template is None:
+            config_template = get_default_template()
+            if config_template is not None:
+                if config_template in available_templates():
+                    template = config_template
+                else:
+                    print(
+                        f"Warning: default_template '{config_template}' in "
+                        "~/.latex-forge.toml does not match any available template — ignoring.",
+                        file=sys.stderr,
+                    )
+            if template is None:
+                if not _is_interactive():
+                    print("--template is required in non-interactive mode.", file=sys.stderr)
+                    return 1
+                template = _select_template_interactively()
+                guided = True
+
+        if args.output is not None:
+            output_dir = Path(args.output).resolve()
+        elif guided:
+            output_dir = _ask_output_dir()
+        else:
+            config_dir = get_default_output_dir()
+            output_dir = config_dir if config_dir is not None else Path.cwd()
+
+        first_run = is_first_run()
+        if first_run:
+            run_first_launch_check()
+            mark_initialized()
+
+        try:
+            target_dir, main_tex_file = create_project(
+                name=name,
+                template=template,
+                output_dir=output_dir,
+            )
+        except (ValueError, FileExistsError) as exc:
+            print(str(exc), file=sys.stderr)
+            return 1
+
+        print(f"Project created: {target_dir}")
+        print(f"Edit: {main_tex_file.relative_to(target_dir.parent)}")
+        if template in ("cv-fr", "cv-en"):
+            first_file = "sections/en-tete.tex" if template == "cv-fr" else "sections/heading.tex"
+            print(f"Next: fill in {first_file} then save to compile.")
+        else:
+            print("Next: fill in frontmatter/metadata.tex then save to compile.")
+
+        if not first_run:
+            warn_if_latex_missing()
+
+        offer_open_vscode(target_dir)
+
+        return 0
+
+    if args.command == "rename":
+        try:
+            if len(args.names) == 1:
+                target_dir, main_tex_file = rename_current_project(
+                    new_name=args.names[0],
+                )
+            elif len(args.names) == 2:
+                target_dir, main_tex_file = rename_project(
+                    old_name=args.names[0],
+                    new_name=args.names[1],
+                )
+            else:
+                print(
+                    "Usage: latex-forge rename <new-name> "
+                    "or latex-forge rename <old-name> <new-name>",
+                    file=sys.stderr,
+                )
+                return 1
+        except (FileNotFoundError, FileExistsError) as exc:
+            print(str(exc), file=sys.stderr)
+            return 1
+
+        print(f"Project renamed: {target_dir}")
+        print(f"Main file: {main_tex_file.name}")
+        return 0
+
+    if args.command == "setup":
+        return run_setup(
+            check_only=args.check_only,
+            skip_extensions=args.skip_extensions,
+            install_tex=args.install_tex,
+        )
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

latex_forge/config.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib  # type: ignore[no-redef]
+    except ImportError:
+        tomllib = None  # type: ignore[assignment]
+
+_CONFIG_PATH = Path.home() / ".latex-forge.toml"
+
+
+def load_config() -> dict:
+    if tomllib is None or not _CONFIG_PATH.exists():
+        return {}
+    try:
+        with open(_CONFIG_PATH, "rb") as f:
+            return tomllib.load(f)
+    except Exception:
+        return {}
+
+
+def get_default_template() -> str | None:
+    value = load_config().get("default_template")
+    return value if isinstance(value, str) and value else None
+
+
+def get_default_output_dir() -> Path | None:
+    value = load_config().get("default_output_dir")
+    if not isinstance(value, str) or not value:
+        return None
+    path = Path(value).expanduser().resolve()
+    return path if path.is_dir() else None
+
+
+def get_profile() -> dict:
+    raw = load_config().get("profile", {})
+    return raw if isinstance(raw, dict) else {}
+
+
+def save_profile(profile: dict) -> None:
+    existing_content = _CONFIG_PATH.read_text(encoding="utf-8") if _CONFIG_PATH.exists() else ""
+
+    # Rebuild file without the existing [profile] section
+    lines: list[str] = []
+    in_profile = False
+    for line in existing_content.splitlines():
+        if line.strip() == "[profile]":
+            in_profile = True
+            continue
+        if in_profile:
+            if line.strip().startswith("["):
+                in_profile = False
+                lines.append(line)
+            # else: skip profile lines
+        else:
+            lines.append(line)
+
+    # Strip trailing blank lines
+    while lines and not lines[-1].strip():
+        lines.pop()
+
+    # Append new [profile] section
+    if lines:
+        lines.append("")
+    lines.append("[profile]")
+    for key in ("name", "university", "program", "github"):
+        value = profile.get(key, "")
+        if value:
+            lines.append(f'{key} = "{value}"')
+
+    _CONFIG_PATH.write_text("\n".join(lines) + "\n", encoding="utf-8")