src-ContextPack.xml

<?xml version="1.0" encoding="UTF-8"?>
<project>

  <context>
    This XML file was automatically generated by ContextPack for project "src".
    It consolidates all project files for analysis, documentation, and AI-assisted refactoring.
    Binary files are listed in <structure> but excluded from <file> blocks.
  </context>
  <structure>
    <path>evermod\main.py</path>
    <path>evermod\commands\add.py</path>
    <path>evermod\commands\contextpack.py</path>
    <path>evermod\commands\create.py</path>
    <path>evermod\commands\init.py</path>
    <path>evermod\commands\update.py</path>
    <path>evermod\commands\version.py</path>
    <path>evermod\fs\builder.py</path>
    <path>evermod\fs\environment.py</path>
    <path>evermod\fs\io.py</path>
    <path>evermod\fs\manifest.py</path>
    <path>evermod\fs\paths.py</path>
    <path>evermod\io\prompt.py</path>
    <path>evermod\services\git.py</path>
    <path>evermod\services\gradle.py</path>
    <path>evermod\utils\sanitize.py</path>
  </structure>

  <file name="evermod\main.py">
import argparse
import sys
import os

if not getattr(sys, 'frozen', False):
    src_path = os.path.dirname(os.path.dirname(__file__))
    if src_path not in sys.path:
        sys.path.insert(0, src_path)

from evermod.commands import init, create, add, contextpack, update, version

def main():
    parser = argparse.ArgumentParser(
        prog="evermod",
        description="EverMod CLI — Modular Forge modding workspace manager"
    )

    parser.add_argument(
        "-v", "--version",
        action="store_true",
        help="Show EverMod version information"
    )

    subparsers = parser.add_subparsers(dest="command")

    # Init
    init_parser = subparsers.add_parser("init", help="Create a new workspace")
    init_parser.add_argument("-p", "--path", metavar="PATH", help="Workspace directory (defaults to current directory)")

    # Create
    create_parser = subparsers.add_parser("create", help="Create a new mod from a Forge MDK template")
    create_parser.add_argument("-s", "--space", metavar="PATH", help="workspace where the mod will be created (defaults to current directory)")

    # add
    add_parser = subparsers.add_parser("add", help="Add EverMod to existing project")
    add_parser.add_argument("-p", "--path", metavar="PATH", help="Target directory where EverMod will be added")

    # contextpack
    contextpack_parser = subparsers.add_parser("contextpack", help="Generate contextpack documentation for mods")
    contextpack_parser.add_argument("target", nargs="?", default=".", help="Target project")

    # update
    update_parser = subparsers.add_parser("update", help="Update the EverMod templates")
    update_parser.add_argument("--force", action="store_true", help="Force update even if versions are the same")
    update_parser.add_argument("--silent", action="store_true", help="Run update in silent mode (no prompts)")

    args = parser.parse_args()

    if args.version:
      version.show_full_version()
      return

    match args.command:
        case "init": init.run(args.path)
        case "create": create.run(args.space)
        case "add": add.run(args.path)
        case "contextpack": contextpack.run(args.target)
        case "update": update.run(args.force, args.silent)
        case _: parser.print_help()

if __name__ == "__main__":
    main()

  </file>
  <file name="evermod\commands\add.py">
from pathlib import Path
from evermod.fs.paths import resolve_path
from evermod.services.gradle import version_context
from evermod.services.git import addSubmodule, git_init
from evermod.fs.environment import Environment, detect_environment
from evermod.fs.builder import render_evermod_setting, render_build
from evermod.fs.manifest import evermod_exists, write_manifest, get_sp_data, get_mc_data

def run(path: str | None):
    print("🧩 EverMod — Add EverMod to existing environment")
    print("---------------------------------------")
    context_path = Path(path).resolve() if path else Path.cwd()
    env = detect_environment(context_path, force_space=bool(path))

    match env:
        case Environment.MOD:
            workspace = False
            project_type = "mod"
        case Environment.SPACE:
            workspace = True
            project_type = "space"
        case _:
            print("❌ Invalid destination")
            print(f"📂 Route: {context_path}")
            return
    
    if evermod_exists(context_path):
        print("⚠️ EverMod is already present in this project.")
        return
    
    data = get_sp_data(context_path) if workspace else get_mc_data(context_path)
    if not data:
        print("❌ Unable to resolve project data")
        return

    project_name, mc_data = data

    setting_context = {
        "project_name": project_name,
        "include_evermod": True,
        "includes": [],
        "workspace": workspace
    }

    for data in mc_data:
        context = version_context(data["version"]).copy()
        context.update(setting_context.copy())
        path_build = resolve_path(context_path, data["path"])
        render_build(path_build, context)
        if workspace:
            setting_context["includes"].append(f"include('mods:{data['mod_name']}')")

    render_evermod_setting(context_path, setting_context)

    try:
        git_init(context_path)
        addSubmodule("wipodev", "EverMod", context_path)
    except Exception as e:
        print(f"❌ Failed to add EverMod: {e}")
        return
    
    write_manifest(path=context_path, project_name=project_name, type_=project_type, evermod=True, minecraft=mc_data)
    
    print("✅ EverMod successfully added to the project.")
    print(f"📂 Location: {context_path}")
    print("---------------------------------------")
  </file>
  <file name="evermod\commands\contextpack.py">
import os
import json
from pathlib import Path
from xml.sax.saxutils import escape
import pathspec
import re

command = "ContextPack"

# ─────────────────────────────────────────────
# ⚙️  Utility functions
# ─────────────────────────────────────────────

def load_gitignore(base_path: Path):
    """Load patterns from .gitignore and compile with pathspec."""
    gitignore_path = base_path / ".gitignore"
    if not gitignore_path.exists():
        return None
    lines = gitignore_path.read_text(encoding="utf-8").splitlines()
    return pathspec.PathSpec.from_lines("gitwildmatch", lines)

def load_config(base_path: Path) -&gt; dict:
    f"""Load {command} config file ({command}.config.json) or return defaults."""
    config_path = base_path / f"{command}.config.json"
    config = {
        "exclude": [
            ".git",
            ".gitignore",
            ".gitattributes",
            "build",
            "dist",
            "__pycache__",
            "__init__.py",
            "*.log",
            "*.zip",
            ".idea",
            ".vscode"
        ],
        "use_gitignore": True,
        "output": None,
        "follow_symlinks": False
    }

    if config_path.exists():
        try:
            user_data = json.loads(config_path.read_text(encoding="utf-8"))
            if "exclude" in user_data:
                config["exclude"] = list(set(config["exclude"] + user_data["exclude"]))
            for key, value in user_data.items():
                if key != "exclude":
                    config[key] = value
        except Exception as e:
            print(f"⚠️  Could not parse config: {e}")
    return config
 
def is_binary_file(path: Path) -&gt; bool:
    """Detect if a file is binary by inspecting its first bytes."""
    try:
        with open(path, "rb") as f:
            chunk = f.read(1024)
        if not chunk:
            return False
        if b"\0" in chunk:
            return True
        text_chars = bytearray({7,8,9,10,12,13,27} | set(range(0x20, 0x100)))
        non_text = chunk.translate(None, text_chars)
        return len(non_text) / len(chunk) &gt; 0.2
    except Exception:
        return False

def count_tokens(text: str) -&gt; int:
    """Estimate tokens by splitting words and symbols (approximation)."""
    return len(re.findall(r"\w+|[^\w\s]", text))

# ─────────────────────────────────────────────
# 🧩  Main command
# ─────────────────────────────────────────────

def run(project_path: str = "."):
    base_path = Path(project_path).resolve()
    project_name = base_path.name
    config = load_config(base_path)

    gitignore_spec = load_gitignore(base_path) if config.get("use_gitignore", True) else None
    exclude_patterns = config["exclude"]
    output_name = config["output"] or f"{project_name}-{command}.xml"
    output_file = base_path / output_name
    follow_symlinks = config.get("follow_symlinks", False)

    # helper: exclusion rules
    def should_exclude(path: Path) -&gt; bool:
        from fnmatch import fnmatch
        rel = str(path.relative_to(base_path))
        if gitignore_spec and gitignore_spec.match_file(rel):
            return True
        for pattern in exclude_patterns:
            if fnmatch(path.name, pattern) or fnmatch(rel, pattern):
                return True
        return False

    # ─────────────────────────────
    #  Scan files
    # ─────────────────────────────
    print(f"📦 Generating {command} for {project_name} ...\n")

    all_files, binary_files, total_chars, total_tokens = [], [], 0, 0

    for root, dirs, files in os.walk(base_path, followlinks=follow_symlinks):
        root_path = Path(root)
        dirs[:] = [d for d in dirs if not should_exclude(root_path / d)]

        for file in files:
            full_path = root_path / file
            if should_exclude(full_path):
                continue
            all_files.append(full_path)

    if not all_files:
        print("⚠️  No files found after filtering.")
        return

    print(f"🧩 Found {len(all_files)} total files. Processing...\n")

    with open(output_name, "w", encoding="utf-8") as out:
        out.write('&lt;?xml version="1.0" encoding="UTF-8"?&gt;\n&lt;project&gt;\n')

        intro = f"""
  &lt;context&gt;
    This XML file was automatically generated by {command} for project "{project_name}".
    It consolidates all project files for analysis, documentation, and AI-assisted refactoring.
    Binary files are listed in &lt;structure&gt; but excluded from &lt;file&gt; blocks.
  &lt;/context&gt;
"""
        out.write(intro)
        out.write("  &lt;structure&gt;\n")

        for path in all_files:
            rel = path.relative_to(base_path)
            if is_binary_file(path):
                out.write(f'    &lt;path type="binary"&gt;{rel}&lt;/path&gt;\n')
                binary_files.append(rel)
            else:
                out.write(f"    &lt;path&gt;{rel}&lt;/path&gt;\n")
        out.write("  &lt;/structure&gt;\n\n")

        # file contents
        for path in all_files:
            rel = path.relative_to(base_path)
            if rel in binary_files:
                continue
            try:
                content = path.read_text(encoding="utf-8", errors="ignore")
                total_chars += len(content)
                total_tokens += count_tokens(content)
            except Exception as e:
                print(f"⚠️  Could not read {path}: {e}")
                continue

            out.write(f'  &lt;file name="{rel}"&gt;\n{escape(content)}\n  &lt;/file&gt;\n')

        out.write("&lt;/project&gt;\n")

    # ─────────────────────────────
    #  Output summary
    # ─────────────────────────────
    YELLOW = "\033[33m"
    GREEN = "\033[92m"
    RESET = "\033[0m"

    print("✔ Packing completed successfully!\n")

    if binary_files:
        print("📄 Binary Files Detected:")
        print("─────────────────────────")
        print(f"{YELLOW}{len(binary_files)} files detected as binary by content inspection:{RESET}")
        for i, f in enumerate(binary_files, 1):
            print(f"{i}. {f}")
        print()
        print(f"{YELLOW}These files have been excluded from the output.{RESET}")
        print(f"{YELLOW}Please review them if you expected them to contain text content.{RESET}\n")

    print("📊 Pack Summary:")
    print("────────────────")
    print(f"  Total Files: {len(all_files)} files")
    print(f" Total Tokens: {total_tokens:,} tokens")
    print(f"  Total Chars: {total_chars:,} chars")
    print(f"       Output: {output_file.name}")
    print(f"     Security: ✔ No suspicious files detected\n")
    print(f"{GREEN}🎉 All Done!{RESET}")
    print("Your project has been successfully packed.")

  </file>
  <file name="evermod\commands\create.py">
from pathlib import Path
from evermod.io.prompt import ask, ask_bool
from evermod.services.gradle import get_versions_data
from evermod.services.git import addSubmodule, git_init
from evermod.fs.environment import Environment, detect_environment
from evermod.utils.sanitize import sanitize_string, sanitize_package
from evermod.fs.builder import create_mod_structure, render_evermod_setting
from evermod.fs.manifest import evermod_exists, write_manifest, get_sp_data

def run(space: str | None):
    print("🧩 EverMod — Mod creation wizard")
    print("--------------------------------")
    context_path = Path(space).resolve() if space else Path.cwd()
    env = detect_environment(context_path, force_space=bool(space))

    match env:
        case Environment.MOD:
            print("❌ You are inside a mod project")
            print(f"📂 Route: {context_path}")
            return
        case Environment.INVALID:
            print("❌ Invalid destination")
            print(f"📂 Route: {context_path}")
            return
        case Environment.SPACE:
            workspace = True
        case Environment.EMPTY_OR_NEW:
            workspace = False

    versions = get_versions_data()
    if not versions:
        print("❌ Unable to fetch version data")
        return

    mod_name = ask("Mod name", "NewMod")
    mod_dir = context_path / "mods" / mod_name if workspace else context_path / mod_name
    if mod_dir.exists():
        print(f"⚠️ Folder '{mod_name}' already exists in {context_path}")
        return
    
    suggested_modid = sanitize_string(mod_name)
    mod_id = sanitize_string(ask("Mod ID", suggested_modid))

    print("\nAvailable Minecraft versions:")
    for v in versions.keys(): print(f" - {v}")
    mc_version = ask("Select Minecraft version", list(versions.keys())[0])
    if mc_version not in versions:
        print(f"❌ Unsupported version: {mc_version}")
        return
    
    author = ask("Author name", "WipoDev")
    safe_author = sanitize_string(author)
    package_default = f"net.{safe_author}.{mod_id}"
    package_name = sanitize_package(ask("Package name", package_default))
    package_parts = package_name.split(".")

    mc_data: list[dict] = []

    if workspace:
        include_evermod = evermod_exists(context_path)
        sp_data = get_sp_data(context_path)
        if not sp_data:
            print("❌ Unable to read workspace data")
            return
        project_name, mc_data = sp_data
        root_path = context_path
        relative_path = f"./mods/{mod_name}"
        project_type = "space"
    else:
        include_evermod = ask_bool("Include EverMod as submodule?")
        project_name = mod_name
        root_path = mod_dir
        relative_path = f"."
        project_type = "mod"

    context = versions[mc_version].copy()
    context.update({
        "minecraft_version": mc_version,
        "mod_id": mod_id,
        "mod_group": safe_author,
        "mod_name": mod_name,
        "mod_authors": author,
        "package_name": package_name,
        "project_name": project_name,
        "include_evermod": include_evermod,
    })

    create_mod_structure(mod_dir, package_parts, context, workspace)

    if not any(
        entry["mod_name"] == mod_name or entry["path"] == relative_path
        for entry in mc_data
    ):
        mc_data.append({
            "mod_name": mod_name,
            "version": mc_version,
            "path": relative_path
        })

    if workspace:
        setting_context = {
            "project_name": project_name,
            "include_evermod": include_evermod,
            "includes": [],
            "workspace": workspace
        }
        for data in mc_data:
            setting_context["includes"].append(f"include('mods:{data['mod_name']}')")
        render_evermod_setting(context_path, setting_context)

    if include_evermod and not workspace:
        git_init(mod_dir)
        include_evermod = addSubmodule("wipodev", "EverMod", mod_dir)
    
    write_manifest(path=root_path, project_name=project_name, type_=project_type, evermod=include_evermod, minecraft=mc_data)

    print(f"\n✅ Mod '{mod_name}' created successfully!")
    print(f"📦 Minecraft {mc_version} (Forge {context['forge_version']})")
    print(f"🔌 EverMod: {'Included as submodule' if include_evermod else 'Not included'}")
    print(f"🏗️ Workspace mode: {'ON' if workspace else 'OFF'}")
    print(f"📂 Location: {mod_dir}")
    print("--------------------------------")
  </file>
  <file name="evermod\commands\init.py">
from pathlib import Path
from evermod.fs.manifest import write_manifest
from evermod.services.git import addSubmodule, git_init
from evermod.io.prompt import ask, ask_bool
from evermod.utils.sanitize import sanitize_string
from evermod.fs.environment import Environment, detect_new_space_environment
from evermod.fs.builder import create_space_structure

def run(path: str | None):
    print("🧩 EverMod — Initialize workspace")
    print("--------------------------------")
    context_path = Path(path).resolve() if path else Path.cwd()
    space_name = sanitize_string(ask("Space name", "NewSpace"))
    space_dir = context_path / space_name

    env = detect_new_space_environment(space_dir)

    if not env == Environment.EMPTY_OR_NEW:
        print("❌ Target directory already exists and is not empty.")
        print("👉 Space initialization requires an empty directory.")
        print(f"📂 Route: {space_dir}")
        return
    
    include_evermod = ask_bool("Include EverMod in this workspace?")

    context = {
        "project_name": space_name,
        "include_evermod": include_evermod,
    }
    create_space_structure(space_dir, context)

    if include_evermod:
        git_init(space_dir)
        include_evermod = addSubmodule("wipodev", "EverMod", space_dir)
        
    write_manifest(path=space_dir, project_name=space_name, type_="space", evermod=include_evermod)

    print("\n✅ Workspace initialized successfully!")
    print(f"🔌 EverMod: {'Enabled' if include_evermod else 'Not included'}")
    print(f"📂 Location: {space_dir}")
    print("--------------------------------")
  </file>
  <file name="evermod\commands\update.py">
import json, shutil, tempfile, subprocess, urllib.request
from pathlib import Path
from packaging import version
from evermod.fs.paths import get_global_dir, get_templates_dir

MANIFEST_URL = "https://raw.githubusercontent.com/wipodev/evermod-templates/main/manifest.json"
REPO_URL = "https://github.com/wipodev/evermod-templates.git"

def run(force: bool = False, silent: bool = False):
    global_dir = get_global_dir()
    templates_dir = get_templates_dir()
    local_manifest_path = global_dir / "manifest.json"

    if not silent:
        print("🔍 Checking for EverMod template updates...")

    # === Fetch remote manifest ===
    try:
        with urllib.request.urlopen(MANIFEST_URL) as response:
            remote_manifest = json.load(response)
    except Exception as e:
        if not silent:
            print(f"❌ Unable to read remote manifest: {e}")
        return

    remote_version = remote_manifest.get("version", "0.0.0")
    local_version = "0.0.0"

    if local_manifest_path.exists():
        try:
            local_data = json.loads(local_manifest_path.read_text(encoding="utf-8"))
            local_version = local_data.get("version", "0.0.0")
        except Exception:
            pass

    remote_v = version.parse(remote_version)
    local_v = version.parse(local_version)

    # === Skip if already up to date ===
    if not force and remote_v &lt;= local_v:
        if not silent:
            print(f"✅ Templates are already up to date (v{local_version}).")
            print("ℹ️  Use '--force' to reinstall templates anyway.")
        return

    # === Show changelog if interactive ===
    if not silent:
        print(f"🆕 New version available: v{remote_version} (current v{local_version})")
        print(f"📅 Released: {remote_manifest.get('released', 'unknown date')}")
        print("\n📋 Changelog:")
        for line in remote_manifest.get("changelog", []):
            print(f"  • {line}")
        print()

        confirm = input("Would you like to update your local templates? (y/n): ").strip().lower()
        if confirm != "y":
            print("❎ Update cancelled.")
            return

    # === Clone and replace templates ===
    with tempfile.TemporaryDirectory() as tmp:
        tmp_path = Path(tmp)
        if not silent:
            print("⬇️  Downloading new templates...")

        try:
            subprocess.run(
                ["git", "clone", "--depth", "1", REPO_URL, str(tmp_path)],
                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True
            )
        except subprocess.CalledProcessError:
            if not silent:
                print("❌ Failed to clone the repository.")
            return

        remote_templates = tmp_path / "templates"
        if not remote_templates.exists():
            if not silent:
                print("❌ Remote repository does not contain 'templates' folder.")
            return

        if templates_dir.exists():
            shutil.rmtree(templates_dir)
        shutil.copytree(remote_templates, templates_dir)

        local_manifest_path.write_text(
            json.dumps(remote_manifest, indent=2), encoding="utf-8"
        )

        if not silent:
            print(f"✅ Templates updated successfully to version v{remote_version}.")
            print(f"📁 Location: {templates_dir}")

  </file>
  <file name="evermod\commands\version.py">
from evermod.fs.io import read_json
from evermod.fs.paths import get_global_dir, get_cli_manifest_path, get_template_manifest

def show_full_version():
    """Display CLI version, framework compatibility, and templates info."""

    # --- CLI Manifest (local root) ---
    cli_manifest = read_json(get_cli_manifest_path())
    if cli_manifest is None: 
        cli_version = "unknown"
    else:
        cli_version = cli_manifest.get("version", "unknown")

    # --- Templates Manifest (global .evermod folder) ---
    template_manifest = read_json(get_template_manifest())
    if template_manifest is None:
        templates_version = "not installed"
        templates_date = "—"
    else:
        templates_version = template_manifest.get("version", "not installed")
        templates_date = template_manifest.get("released", "unknown date")

    # --- Output summary ---
    print("🧩 EverMod CLI Information")
    print("----------------------------")
    print(f"CLI Version:           v{cli_version}")
    print(f"Installed Templates:   v{templates_version}")
    print(f"Templates Released:    {templates_date}")
    print(f"Global Path:           {get_global_dir()}")

  </file>
  <file name="evermod\fs\builder.py">
import shutil
from pathlib import Path
from jinja2 import Template
from typing import Iterable
from evermod.fs.paths import get_templates_dir

#-----------------------------------------------------------
def create_mod_structure(mod_dir: Path, package_parts: list[str], context: dict, space: bool = False):
    """Create folder structure and copy static template files."""
    src_main_java = mod_dir / "src" / "main" / "java"
    src_main_java_mod = src_main_java / Path(*package_parts)
    src_main_resources = mod_dir / "src" / "main" / "resources"
    src_main_metainf = src_main_resources / "META-INF"

    mod_dir.mkdir(parents=True, exist_ok=True)
    src_main_java_mod.mkdir(parents=True, exist_ok=True)
    src_main_resources.mkdir(parents=True, exist_ok=True)
    src_main_metainf.mkdir(parents=True, exist_ok=True)

    copy_files([("mods.toml", src_main_metainf / "mods.toml"),])
    copy_extra(mod_dir)
    if not space: copy_gradle(mod_dir)
    render_mod(mod_dir, context, src_main_java_mod, src_main_resources, space)

#-----------------------------------------------------------
def create_space_structure(space_dir: Path, context: dict):
    mods = space_dir / "mods"
    space_dir.mkdir(parents=True, exist_ok=True)
    mods.mkdir(parents=True, exist_ok=True)
    copy_extra(space_dir)
    copy_gradle(space_dir, True)
    render_files([("template.settings.gradle.j2", space_dir / "settings.gradle"),], context)

#-----------------------------------------------------------
def copy_extra(path: Path):
    copy_files([
        (".gitignore", path / ".gitignore"),
        (".gitattributes", path / ".gitattributes"),
        ("LICENSE.txt", path / "LICENSE.txt"),
    ])

#-----------------------------------------------------------
def copy_gradle(path: Path, space: bool = False):
    gradle_dir = path / "gradle" / "wrapper"
    gradle_dir.mkdir(parents=True, exist_ok=True)
    copy_files([
        ("gradlew", path / "gradlew"),
        ("gradlew.bat", path / "gradlew.bat"),
        ("gradle/wrapper/gradle-wrapper.jar", gradle_dir / "gradle-wrapper.jar"),
        ("gradle/wrapper/gradle-wrapper.properties", gradle_dir / "gradle-wrapper.properties"),
    ])
    if space:
        copy_files([
            ("template.space.build.gradle.j2", path / "build.gradle"),
            ("template.space.gradle.properties.j2", path / "gradle.properties"),
        ])

#-----------------------------------------------------------
def render_mod(mod_dir: Path, context: dict, src_main_java: Path, src_main_resources: Path, space: bool = False) -&gt; None:
    render_files([
        ("template.build.gradle.j2", mod_dir / "build.gradle"),
        ("template.gradle.properties.j2", mod_dir / "gradle.properties"),
        ("template.MainMod.java.j2", src_main_java / "MainMod.java"),
        ("template.pack.mcmeta.j2", src_main_resources / "pack.mcmeta"),
    ], context)
    if not space:
        render_files([("template.settings.gradle.j2", mod_dir / "settings.gradle"),], context)

#-----------------------------------------------------------
def render_evermod_setting(path: Path, context: dict) -&gt; None:
    render_files([("template.settings.gradle.j2", path / "settings.gradle"),], context)

#-----------------------------------------------------------
def render_build(path: Path, context: dict) -&gt; None:
    render_files([("template.build.gradle.j2", path / "build.gradle"),], context)

#-----------------------------------------------------------
def copy_files(files: Iterable[tuple[Path, Path]]) -&gt; None:
    templates_dir = get_templates_dir()
    for tpl_file, dst_file in files:
        shutil.copy2(templates_dir / tpl_file, dst_file)

#-----------------------------------------------------------
def render_files(files: Iterable[tuple[Path, Path]], context: dict) -&gt; None:
    templates_dir = get_templates_dir()
    for tpl, output in files:
        render_template(templates_dir / tpl, context, output)

#-----------------------------------------------------------
def render_template(template_path: Path, context: dict, output_path: Path):
    """Render a Jinja2 template and write to destination."""
    with open(template_path, encoding="utf-8") as f:
        template = Template(f.read())
    result = template.render(context)
    output_path.write_text(result, encoding="utf-8")
  </file>
  <file name="evermod\fs\environment.py">
from enum import Enum
from pathlib import Path
from evermod.fs.paths import is_empty_dir
from evermod.fs.manifest import is_environment_mod, is_environment_space

#-----------------------------------------------------------
class Environment(Enum):
    MOD = "mod"
    SPACE = "space"
    EMPTY_OR_NEW = "empty_or_new"
    INVALID = "invalid"

#-----------------------------------------------------------
def detect_environment(context_path: Path, force_space: bool = False) -&gt; Environment:
    if not context_path.exists() or not context_path.is_dir():
        return Environment.INVALID

    if is_environment_mod(context_path):
        return Environment.MOD

    if is_environment_space(context_path):
        return Environment.SPACE

    if force_space:
        return Environment.INVALID

    return Environment.EMPTY_OR_NEW

#-----------------------------------------------------------
def detect_new_space_environment(context_path: Path) -&gt; Environment:
    if not context_path.exists():
        return Environment.EMPTY_OR_NEW
    
    if not is_empty_dir(context_path):
        return Environment.INVALID
    
    return Environment.EMPTY_OR_NEW

  </file>
  <file name="evermod\fs\io.py">
import json, re
from pathlib import Path
from typing import Iterable

#-----------------------------------------------------------
def read_text(path: Path) -&gt; str | None:
    if not path.exists():
        return None
    try:
        return path.read_text(encoding="utf-8")
    except Exception:
        return None

#-----------------------------------------------------------
def write_text(path: Path, content: str):
    path.write_text(content, encoding="utf-8")

#-----------------------------------------------------------
def read_json(path: Path) -&gt; dict | None:
    if not path.exists():
        return None
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except Exception:
        return None

#-----------------------------------------------------------
def write_json(path: Path, data: dict):
    path.write_text(
        json.dumps(data, indent=2),
        encoding="utf-8"
    )

#-----------------------------------------------------------
def file_contains(path: Path, word: str) -&gt; bool:
    content = read_text(path)
    return content is not None and word in content

#-----------------------------------------------------------
def file_contains_strict(path: Path, word: str) -&gt; bool:
    content = read_text(path)
    return (
        content is not None
        and re.search(rf"\b{re.escape(word)}\b", content) is not None
    )

#-----------------------------------------------------------
def read_key_values(path: Path, keys: Iterable[str], comment_prefixes=("#", "//")) -&gt; dict[str, str]:
    result = {}
    content = read_text(path)
    if content is None:
        return result
    keys = set(keys)
    try:
        for raw_line in content.splitlines():
            line = raw_line.strip()
            if not line: continue
            if any(line.startswith(p) for p in comment_prefixes): continue
            if "=" not in line: continue
            key, value = line.split("=", 1)
            key = key.strip()
            if key not in keys: continue
            value = value.strip()
            if (
                (value.startswith('"') and value.endswith('"')) or
                (value.startswith("'") and value.endswith("'"))
            ):
                value = value[1:-1]
            result[key] = value
    except Exception:
        pass
    return result
  </file>
  <file name="evermod\fs\manifest.py">
from pathlib import Path
from evermod.fs.io import read_key_values
from evermod.fs.io import read_json, write_json, file_contains

MANIFEST = "evermod.manifest.json"

#-----------------------------------------------------------
def write_manifest(path: Path, project_name: str, type_: str, evermod: bool, minecraft: list[dict] | None = None):
    data = {
        "project_name": project_name,
        "type": type_,
        "version": 1,
        "evermod": evermod,
        "minecraft": minecraft or [],
    }
    write_json(path / MANIFEST, data)

#-----------------------------------------------------------
def read_manifest(path: Path) -&gt; dict | None:
    return read_json(path / MANIFEST)

#-----------------------------------------------------------
def evermod_exists(path: Path) -&gt; bool:
    manifest = read_manifest(path)
    if manifest and manifest.get("evermod") is True:
        return True

    if (path / "EverMod").exists() or (path / "evermod").exists():
        return True

    return file_contains(path / "settings.gradle", "EverMod")

#-----------------------------------------------------------
def is_environment_mod(path: Path) -&gt; bool:
    manifest = read_manifest(path)
    if manifest:
        return manifest.get("type") == "mod"
    
    build_path = path / "build.gradle"

    if not build_path.exists():
        return False

    if file_contains(build_path, "minecraftforge"):
        return True

    if (path / "src" / "main" / "java").exists() and (path / "src" / "main" / "resources").exists():
        return True

    return False

#-----------------------------------------------------------
def is_environment_space(path: Path) -&gt; bool:
    manifest = read_manifest(path)
    if manifest:
        return manifest.get("type") == "space"
    
    build_path = path / "build.gradle"

    if not build_path.exists():
        return False

    if not file_contains(build_path, "minecraftforge"):
        return True

    return False

#-----------------------------------------------------------
def get_manifest_minecraft_data(path: Path) -&gt; tuple[str | None, list[dict] | None] | None:
    manifest = read_manifest(path)
    if manifest:
        mc = manifest.get("minecraft")
        name = manifest.get("project_name")
        if mc or name:
            return name, mc
    return None

#-----------------------------------------------------------
def get_mc_data(path: Path) -&gt; tuple[str | None, list[dict] | None] | None:
    manifest_mc_data = get_manifest_minecraft_data(path)
    if manifest_mc_data is not None:
        return manifest_mc_data

    mod_data = get_mod_data(path)
    if mod_data is not None:
        name, mc = mod_data
        return (name, [mc])

    return None

#-----------------------------------------------------------
def get_sp_data(path: Path) -&gt; tuple[str | None, list[dict] | None] | None:
    manifest_mc_data = get_manifest_minecraft_data(path)
    if manifest_mc_data is not None:
        return manifest_mc_data

    data = read_key_values(path / "settings.gradle", keys=["rootProject.name"])
    if data: name = data.get("rootProject.name")

    mods_dir = path / "mods"
    if not mods_dir.exists() or not mods_dir.is_dir():
        return (name, [])

    mc_data: list[dict] = []
    seen_mods: set[str] = set()
    seen_paths: set[str] = set()

    for mod_dir in mods_dir.iterdir():
        if not mod_dir.is_dir(): continue

        mod_data = get_mod_data(mod_dir)
        if not mod_data: continue

        mod_name, mc_entry = mod_data
        if not mc_entry: continue

        mod_path = f"./mods/{mod_dir.name}"

        if mod_name in seen_mods or mod_path in seen_paths: continue

        mc_entry = mc_entry.copy()
        mc_entry["path"] = mod_path

        mc_data.append(mc_entry)
        seen_mods.add(mod_name)
        seen_paths.add(mod_path)

    return (name, mc_data)

#-----------------------------------------------------------
def get_mod_data(path: Path) -&gt; tuple[str | None, dict | None] | None:
    data = read_key_values(path / "gradle.properties", keys=["minecraft_version", "mod_name"])
    if not data: return None

    mc = data.get("minecraft_version")
    name = data.get("mod_name")

    if not mc and not name:
        return None

    return (
        name,
        {
            "mod_name": name,
            "version": mc,
            "path": "."
        }
    )
  </file>
  <file name="evermod\fs\paths.py">
import sys
from pathlib import Path

#-----------------------------------------------------------
def get_global_dir() -&gt; Path:
    """
    Returns the global EverMod configuration directory.
    Example:
      Windows → C:\\Users\\&lt;user&gt;\\.evermod
      Linux/macOS → /home/&lt;user&gt;/.evermod
    """
    base = Path.home() / ".evermod"
    base.mkdir(parents=True, exist_ok=True)
    return base

#-----------------------------------------------------------
def get_templates_dir() -&gt; Path:
    """Returns the path to the global Forge templates directory."""
    templates = get_global_dir() / "templates"
    templates.mkdir(parents=True, exist_ok=True)
    return templates

#-----------------------------------------------------------
def get_template_manifest() -&gt; Path:
    """Returns the manifest.json file inside the global folder."""
    return get_global_dir() / "manifest.json"

#-----------------------------------------------------------
def get_versions_file() -&gt; Path:
    """Returns the versions.json file inside the global templates folder."""
    return get_templates_dir() / "versions.json"

#-----------------------------------------------------------
def get_cli_manifest_path() -&gt; Path:
    """Find manifest.json dynamically whether running from source or compiled .exe."""
    if getattr(sys, 'frozen', False):
        base_path = Path(sys._MEIPASS)
    else:
        base_path = Path(__file__).resolve()
        for parent in base_path.parents:
            candidate = parent / "manifest.json"
            if candidate.exists():
                return candidate
        base_path = Path.cwd()
    return base_path / "manifest.json"

#-----------------------------------------------------------
def resolve_path(context_path: Path | str, mod_path: Path | str) -&gt; Path:
    base = Path(context_path)
    rel = Path(mod_path)

    if rel == Path("."):
        return base.resolve()

    return (base / rel).resolve()

#-----------------------------------------------------------
def is_empty_dir(path: Path) -&gt; bool:
    return path.exists() and path.is_dir() and not any(path.iterdir())
  </file>
  <file name="evermod\io\prompt.py">
def ask(prompt, default=None):
    """Input helper with default value."""
    value = input(f"{prompt} [{default}]: ").strip()
    return value or default

def ask_bool(prompt: str, default: bool = True) -&gt; bool:
    if default:
        suffix = "Y/n"
        default_str = "Y"
    else:
        suffix = "y/N"
        default_str = "N"
    answer = ask(f"{prompt} {suffix}", default_str).strip().lower()
    if answer in ("y", "yes", "s", "si", "sí"):
        return True
    if answer in ("n", "no"):
        return False
    return default
  </file>
  <file name="evermod\services\git.py">
import subprocess
from pathlib import Path

def git_init(path: Path):
    if not (path / ".git").exists():
        subprocess.run(
            ["git", "init"],
            cwd=path,
            check=True
        )

def addSubmodule(user: str, name: str, target_path: str = ".") -&gt; bool:
    target_base = Path(target_path).resolve()  # where to add the submodule
    repo_url = f"https://github.com/{user}/{name}.git"
    dest = target_base / name

    print(f"📦 Adding submodule '{name}' from {repo_url}...")

    if dest.exists():
        print(f"⚠️  A folder named '{name}' already exists in {target_base}")
        return False

    try:
        subprocess.run(["git", "submodule", "add", repo_url, name], cwd=target_base, check=True)
        print(f"✅ Submodule '{name}' added successfully.")
        return True
    except subprocess.CalledProcessError:
        print(f"❌ Failed to add submodule '{name}'.")
        return False
  </file>
  <file name="evermod\services\gradle.py">
import subprocess, json, platform
from pathlib import Path
from evermod.fs.paths import get_versions_file

def refresh_environment():
    print("🔄 Refreshing Gradle and Java environment...")

    gradlew = Path("./gradlew")
    if not gradlew.exists():
        print("⚠️  gradlew not found in this directory.")
        return

    # Detect OS and use correct syntax
    if platform.system() == "Windows":
        gradle_cmd = [".\\gradlew.bat", "--refresh-dependencies"]
    else:
        gradle_cmd = ["./gradlew", "--refresh-dependencies"]

    try:
        subprocess.run(gradle_cmd, check=True, shell=True)
        print("✅ Gradle dependencies refreshed successfully.")
    except subprocess.CalledProcessError:
        print("❌ Failed to refresh Gradle dependencies.")

    print("\n💡 Tip: If you're using VS Code, run this after reload:")
    print("   → Press Ctrl + Shift + P → 'Java: Clean the Java language server workspace'")
    print("   (This ensures Forge and autocompletion are fully reindexed.)")

def get_versions_data():
    versions_path = get_versions_file()
    if not versions_path.exists():
        print("❌ 'versions.json' not found in templates/")
        return
    return json.loads(versions_path.read_text(encoding="utf-8"))

def version_context(mc_version: str):
    versions = get_versions_data()
    if not versions: return
    return versions[mc_version].copy()
  </file>
  <file name="evermod\utils\sanitize.py">
import re

def sanitize_string(s: str) -&gt; str:
    """Sanitize a string to be used as mod ID or similar identifiers."""
    return re.sub(r'[^a-z0-9_]', '_', s.lower().strip().replace(" ", "_"))

def sanitize_package(s: str) -&gt; str:
    """Sanitize a string for use as a Java package (keep dots)."""
    parts = s.lower().strip().replace(" ", "_").split(".")
    return ".".join(re.sub(r'[^a-z0-9_]', '_', p) for p in parts if p)
  </file>
</project>