grimx 0.3.0__py3-none-any.whl

grimx/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

grimx/build.py

@@ -0,0 +1,142 @@
+"""
+grimx.build
+Orchestrate CMake configure, build, test, and run.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import shutil
+from pathlib import Path
+
+import click
+
+BUILD_DIR = "build"
+
+
+def run() -> None:
+    """Configure and build the project."""
+    _require_tool("cmake")
+    _guard_project_root()
+    _cmake_configure()
+    _cmake_build()
+
+
+def run_tests() -> None:
+    """Run tests via CTest."""
+    _require_tool("ctest")
+    _guard_project_root()
+
+    build_path = _build_path()
+    if not build_path.exists():
+        click.echo("No build directory found — running build first...")
+        run()
+
+    click.echo("Running tests...")
+    result = subprocess.run(
+        ["ctest", "--output-on-failure", "--test-dir", str(build_path)],
+    )
+    if result.returncode != 0:
+        raise SystemExit(result.returncode)
+    click.echo("✓ all tests passed")
+
+
+def run_app() -> None:
+    """Run the compiled application binary."""
+    _guard_project_root()
+
+    build_path = _build_path()
+    if not build_path.exists():
+        click.echo("error: no build directory found. Run 'grimx build' first.", err=True)
+        raise SystemExit(1)
+
+    project_name = Path.cwd().name
+    binary = build_path / project_name
+
+    # Fallback: look for any executable in build root
+    if not binary.exists():
+        candidates = [
+            p for p in build_path.iterdir()
+            if p.is_file() and _is_executable(p)
+        ]
+        if not candidates:
+            click.echo("error: no binary found in build/. Run 'grimx build' first.", err=True)
+            raise SystemExit(1)
+        binary = candidates[0]
+
+    click.echo(f"Running {binary.name}...")
+    result = subprocess.run([str(binary)])
+    raise SystemExit(result.returncode)
+
+
+# ---------------------------------------------------------------------------
+# Internal
+# ---------------------------------------------------------------------------
+
+def _cmake_configure() -> None:
+    project_root = Path.cwd()
+    build_path = _build_path()
+    build_path.mkdir(exist_ok=True)
+
+    click.echo("Configuring with CMake...")
+    result = subprocess.run(
+        [
+            "cmake",
+            str(project_root),          # explicit source dir — never ".."
+            f"-B{build_path}",          # explicit build dir
+            "-DCMAKE_BUILD_TYPE=Debug",
+        ],
+        cwd=project_root,
+    )
+    if result.returncode != 0:
+        raise SystemExit(result.returncode)
+
+
+def _cmake_build() -> None:
+    build_path = _build_path()
+    click.echo("Building...")
+    result = subprocess.run(
+        ["cmake", "--build", str(build_path), "--parallel"],
+    )
+    if result.returncode != 0:
+        raise SystemExit(result.returncode)
+    click.echo("✓ build succeeded")
+
+
+def _build_path() -> Path:
+    return Path.cwd() / BUILD_DIR
+
+
+def _guard_project_root() -> None:
+    """Abort with a clear message if not run from a GRIMX project directory."""
+    cwd = Path.cwd()
+    has_cmake = (cwd / "CMakeLists.txt").exists()
+    has_config = (cwd / "grimx.config").exists()
+
+    if not has_cmake and not has_config:
+        click.echo(
+            "error: no CMakeLists.txt or grimx.config found in current directory.\n"
+            "  Run this command from inside a GRIMX project.",
+            err=True,
+        )
+        raise SystemExit(1)
+
+    if not has_cmake:
+        click.echo(
+            "error: CMakeLists.txt not found.\n"
+            "  Make sure your project was scaffolded correctly.",
+            err=True,
+        )
+        raise SystemExit(1)
+
+
+def _require_tool(name: str) -> None:
+    if not shutil.which(name):
+        click.echo(f"error: '{name}' not found in PATH.", err=True)
+        click.echo(f"  Install it and re-run, or check 'grimx doctor' (coming in v2).")
+        raise SystemExit(1)
+
+
+def _is_executable(path: Path) -> bool:
+    import os
+    return os.access(path, os.X_OK)

grimx/cli.py

@@ -0,0 +1,51 @@
+"""
+grimx.cli
+Entry point for the GRIMX command-line interface
+"""
+
+import click 
+from grimx import __version__
+from grimx import scaffold, install as install_mod, build as build_mod 
+
+@click.group()
+@click.version_option(__version__, prog_name="grimx")
+def main():
+    """GRIMX - GNU Runtime & Installation Manager.
+    
+    Minimal tooling for reproducible C and C++ environments.
+    """
+
+@main.command()
+@click.argument("name", required=False, default=None)
+@click.option(
+    "--type",
+    "project_type",
+    default=None,
+    type=click.Choice(["c", "cpp", "embedded-c", "embedded-cpp"], case_sensitive=False),
+    help="Project type (skips prompt if provided).",
+)
+def new(name: str | None, project_type: str | None):
+    """Scaffold a new project interactivity, or pass NAME to skip the name prompt."""
+    scaffold.create_project(name, project_type)
+
+
+@main.command("install")
+@click.argument("package", required=False, default=None)
+def install_cmd(package):
+    """Install a dependency, or restore all from grimx.lock."""
+    install_mod.run(package)
+
+@main.command("build")
+def build_cmd():
+    """Build the project via CMake."""
+    build_mod.run()
+
+@main.command("test")
+def test_cmd():
+    """Run tests via CTest."""
+    build_mod.run_tests()
+
+@main.command("run")
+def run_cmd():
+    """Run the compiled application."""
+    build_mod.run_app()

grimx/config.py

@@ -0,0 +1,84 @@
+"""
+grimx.config
+Read and write grimx.config and grimx.lock using TOML.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+import tomlkit
+
+CONFIG_FILE = "grimx.config"
+LOCK_FILE = "grimx.lock"
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "package_manager": {
+        "priority": ["vcpkg", "conan"],
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Config helpers
+# ---------------------------------------------------------------------------
+
+def load_config(root: Path | None = None) -> dict[str, Any]:
+    """Load grimx.config from root (defaults to cwd)."""
+    path = _resolve(root, CONFIG_FILE)
+    if not path.exists():
+        return dict(DEFAULT_CONFIG)
+    return tomlkit.loads(path.read_text())
+
+
+def write_config(data: dict[str, Any], root: Path | None = None) -> None:
+    path = _resolve(root, CONFIG_FILE)
+    path.write_text(tomlkit.dumps(data))
+
+
+# ---------------------------------------------------------------------------
+# Lock file helpers
+# ---------------------------------------------------------------------------
+
+def load_lock(root: Path | None = None) -> dict[str, Any]:
+    path = _resolve(root, LOCK_FILE)
+    if not path.exists():
+        doc = tomlkit.document()
+        doc["dependencies"] = tomlkit.table()
+        return doc
+    return tomlkit.loads(path.read_text())
+
+
+def write_lock(data: dict[str, Any], root: Path | None = None) -> None:
+    path = _resolve(root, LOCK_FILE)
+    path.write_text(tomlkit.dumps(data))
+
+
+def add_dependency(
+    name: str,
+    manager: str,
+    version: str,
+    root: Path | None = None,
+) -> None:
+    lock = load_lock(root)
+
+    if "dependencies" not in lock:
+        lock["dependencies"] = tomlkit.table()
+
+    entry = tomlkit.inline_table()
+    entry.append("manager", manager)
+    entry.append("version", version)
+
+    lock["dependencies"][name] = entry
+    write_lock(lock, root)
+
+
+# ---------------------------------------------------------------------------
+# Internal
+# ---------------------------------------------------------------------------
+
+def _resolve(root: Path | None, filename: str) -> Path:
+    base = root or Path(os.getcwd())
+    return base / filename

grimx/install.py

@@ -0,0 +1,378 @@
+"""
+grimx.install
+Delegate package installation to vcpkg or Conan with fallback logic.
+Offers to auto-install missing package managers.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import subprocess
+import shutil
+import sys
+from pathlib import Path
+
+import click
+
+from grimx.config import load_config, load_lock, add_dependency
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def run(package: str | None) -> None:
+    if package:
+        _install_package(package)
+    else:
+        _restore_from_lock()
+
+
+# ---------------------------------------------------------------------------
+# Install / restore
+# ---------------------------------------------------------------------------
+
+def _install_package(package: str) -> None:
+    cfg = load_config()
+    priority: list[str] = cfg.get("package_manager", {}).get("priority", [])
+
+    if not priority:
+        click.echo(
+            "error: no package managers configured.\n"
+            "  Edit grimx.config and set priority = [\"vcpkg\"] or [\"conan\"].",
+            err=True,
+        )
+        raise SystemExit(1)
+
+    for manager in priority:
+        if not _is_manager_available(manager):
+            if not _prompt_and_install_manager(manager):
+                continue
+
+        click.echo(f"  trying {manager}...")
+        ok, version = _try_install(manager, package)
+        if ok:
+            add_dependency(package, manager, version)
+            click.echo(f"  ✓ installed {package}=={version} via {manager}")
+            click.echo(f"  ✓ grimx.lock updated")
+            if manager == "vcpkg":
+                _sync_vcpkg_manifest()
+                click.echo(f"  ✓ vcpkg.json updated")
+            return
+
+    click.echo(
+        f"\nerror: could not install '{package}' with any configured manager "
+        f"({', '.join(priority)}).",
+        err=True,
+    )
+    raise SystemExit(1)
+
+
+def _restore_from_lock() -> None:
+    lock = load_lock()
+    deps: dict = lock.get("dependencies", {})
+
+    if not deps:
+        click.echo("grimx.lock is empty — nothing to install.")
+        return
+
+    click.echo(f"Restoring {len(deps)} dependencies from grimx.lock...")
+
+    # Group by manager
+    vcpkg_deps = {k: v for k, v in deps.items() if v["manager"] == "vcpkg"}
+    conan_deps = {k: v for k, v in deps.items() if v["manager"] == "conan"}
+
+    failed = []
+
+    if vcpkg_deps:
+        if not _is_manager_available("vcpkg"):
+            if not _prompt_and_install_manager("vcpkg"):
+                failed.extend(vcpkg_deps.keys())
+                vcpkg_deps = {}
+
+        if vcpkg_deps:
+            if _restore_vcpkg(vcpkg_deps):
+                for name in vcpkg_deps:
+                    click.echo(f"  ✓ {name}")
+            else:
+                failed.extend(vcpkg_deps.keys())
+
+    for name, meta in conan_deps.items():
+        if not _is_manager_available("conan"):
+            if not _prompt_and_install_manager("conan"):
+                click.echo(f"  ✗ {name} — skipped (conan unavailable)", err=True)
+                failed.append(name)
+                continue
+
+        click.echo(f"  installing {name}=={meta['version']} via conan...")
+        ok, _ = _try_install("conan", name)
+        if ok:
+            click.echo(f"  ✓ {name}")
+        else:
+            click.echo(f"  ✗ {name} — install failed", err=True)
+            failed.append(name)
+
+    if failed:
+        click.echo(f"\n{len(failed)} package(s) failed: {', '.join(failed)}", err=True)
+        raise SystemExit(1)
+
+    click.echo(f"\n✓ all dependencies restored")
+
+
+def _restore_vcpkg(deps: dict) -> bool:
+    """Restore vcpkg deps via vcpkg.json manifest for version pinning."""
+    if not _sync_vcpkg_manifest():
+        return False
+
+    click.echo(f"  generated vcpkg.json with {len(deps)} package(s)")
+
+    result = subprocess.run([_vcpkg_bin(), "install"], text=True)
+
+    if result.returncode != 0:
+        click.echo("  error: vcpkg install failed.", err=True)
+        return False
+
+    click.echo("  ✓ all vcpkg dependencies restored")
+    return True
+
+
+def _sync_vcpkg_manifest() -> bool:
+    """Generate vcpkg.json from current grimx.lock state."""
+    lock = load_lock()
+    deps = {k: v for k, v in lock.get("dependencies", {}).items() if v["manager"] == "vcpkg"}
+
+    if not deps:
+        return True
+
+    baseline_result = subprocess.run(
+        ["git", "-C", str(Path.home() / ".vcpkg"), "rev-parse", "HEAD"],
+        capture_output=True, text=True,
+    )
+    if baseline_result.returncode != 0:
+        click.echo("  error: could not get vcpkg baseline.", err=True)
+        return False
+
+    baseline = baseline_result.stdout.strip()
+
+    manifest = {
+        "name": "grimx-project",
+        "version": "0.1.0",
+        "builtin-baseline": baseline,
+        "dependencies": [
+            {"name": name, "version>=": meta["version"]}
+            if meta["version"] != "unknown"
+            else name
+            for name, meta in deps.items()
+        ]
+    }
+
+    manifest_path = Path.cwd() / "vcpkg.json"
+    manifest_path.write_text(json.dumps(manifest, indent=2))
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Manager availability
+# ---------------------------------------------------------------------------
+
+def _is_manager_available(manager: str) -> bool:
+    """Check if a package manager is available via PATH or known install location."""
+    if manager == "vcpkg":
+        return bool(shutil.which("vcpkg")) or (Path.home() / ".vcpkg" / "vcpkg").exists()
+    return bool(shutil.which(manager))
+
+
+def _vcpkg_bin() -> str:
+    """Return vcpkg binary — from PATH or known install location."""
+    return shutil.which("vcpkg") or str(Path.home() / ".vcpkg" / "vcpkg")
+
+
+# ---------------------------------------------------------------------------
+# Auto-install managers
+# ---------------------------------------------------------------------------
+
+def _prompt_and_install_manager(manager: str) -> bool:
+    """Offer to install a missing package manager. Returns True if now available."""
+    hints = {
+        "vcpkg": "https://vcpkg.io/en/getting-started",
+        "conan": "pip install conan",
+    }
+    installers = {
+        "vcpkg": _auto_install_vcpkg,
+        "conan": _auto_install_conan,
+    }
+
+    click.echo(f"\n  '{manager}' is not installed.")
+
+    if manager not in installers:
+        click.echo(f"  No auto-install available for '{manager}'.", err=True)
+        return False
+
+    click.echo(f"  Install hint: {hints[manager]}")
+    if not click.confirm(f"  Install {manager} now?", default=True):
+        click.echo(f"  Skipping {manager}.")
+        return False
+
+    success = installers[manager]()
+
+    if success and _is_manager_available(manager):
+        return True
+
+    click.echo(
+        f"\n  '{manager}' still not found after install.\n"
+        f"  You may need to open a new terminal or add it to PATH manually.",
+        err=True,
+    )
+    return False
+
+
+def _auto_install_vcpkg() -> bool:
+    """Clone and bootstrap vcpkg into ~/.vcpkg and add to session PATH."""
+    vcpkg_dir = Path.home() / ".vcpkg"
+
+    # Already fully installed
+    if vcpkg_dir.exists() and (vcpkg_dir / "vcpkg").exists():
+        click.echo("  vcpkg binary found, skipping clone and bootstrap.")
+        os.environ["PATH"] = str(vcpkg_dir) + os.pathsep + os.environ.get("PATH", "")
+        return True
+
+    # Stale/incomplete clone
+    if vcpkg_dir.exists() and not (vcpkg_dir / "vcpkg").exists():
+        click.echo("  ~/.vcpkg exists but vcpkg binary is missing. Removing and re-cloning...")
+        shutil.rmtree(vcpkg_dir)
+
+    # Fresh clone
+    if not vcpkg_dir.exists():
+        click.echo("  Cloning vcpkg into ~/.vcpkg ...")
+        result = subprocess.run(
+            ["git", "clone", "https://github.com/microsoft/vcpkg.git", str(vcpkg_dir)],
+        )
+        if result.returncode != 0:
+            click.echo("  error: git clone failed.", err=True)
+            return False
+
+    click.echo("  Bootstrapping vcpkg...")
+    if platform.system() == "Windows":
+        bootstrap = vcpkg_dir / "bootstrap-vcpkg.bat"
+        cmd = [str(bootstrap), "-disableMetrics"]
+    else:
+        bootstrap = vcpkg_dir / "bootstrap-vcpkg.sh"
+        cmd = ["bash", str(bootstrap), "-disableMetrics"]
+
+    if not bootstrap.exists():
+        click.echo(f"  error: bootstrap script not found at {bootstrap}", err=True)
+        click.echo(f"  The clone may have failed silently. Try: rm -rf ~/.vcpkg and retry.", err=True)
+        return False
+
+    if platform.system() != "Windows":
+        bootstrap.chmod(bootstrap.stat().st_mode | 0o111)
+
+    result = subprocess.run(cmd)
+    if result.returncode != 0:
+        click.echo("  error: bootstrap failed.", err=True)
+        return False
+
+    _persist_to_path(vcpkg_dir)
+    os.environ["PATH"] = str(vcpkg_dir) + os.pathsep + os.environ.get("PATH", "")
+
+    click.echo(f"  ✓ vcpkg installed at {vcpkg_dir}")
+    return True
+
+
+def _persist_to_path(directory: Path) -> None:
+    """Append directory to PATH in the user's shell profile."""
+    export_line = f'export PATH="{directory}:$PATH"'
+
+    shell = os.environ.get("SHELL", "")
+    if "zsh" in shell:
+        profile = Path.home() / ".zshrc"
+    else:
+        profile = Path.home() / ".bashrc"
+
+    if profile.exists() and export_line in profile.read_text():
+        return
+
+    with profile.open("a") as f:
+        f.write(f"\n# Added by grimx\n{export_line}\n")
+
+    click.echo(f"  ✓ added to {profile} — run 'source {profile}' or open a new terminal")
+
+
+def _auto_install_conan() -> bool:
+    """Install conan via pip, falling back to pipx if pip is blocked."""
+    click.echo("  Installing conan via pip...")
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "install", "conan", "--quiet"],
+    )
+    if result.returncode == 0:
+        click.echo("  ✓ conan installed")
+        return True
+
+    if shutil.which("pipx"):
+        click.echo("  pip blocked — trying pipx...")
+        result = subprocess.run(["pipx", "install", "conan"])
+        if result.returncode == 0:
+            local_bin = str(Path.home() / ".local" / "bin")
+            os.environ["PATH"] = local_bin + os.pathsep + os.environ.get("PATH", "")
+            click.echo("  ✓ conan installed via pipx")
+            return True
+
+    click.echo("  error: could not install conan.", err=True)
+    click.echo("  Try manually: pip install conan  or  pipx install conan", err=True)
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Package manager wrappers
+# ---------------------------------------------------------------------------
+
+def _try_install(manager: str, package: str) -> tuple[bool, str]:
+    if manager == "vcpkg":
+        return _vcpkg_install(package)
+    if manager == "conan":
+        return _conan_install(package)
+    return False, ""
+
+
+def _vcpkg_install(package: str) -> tuple[bool, str]:
+    result = subprocess.run(
+        [_vcpkg_bin(), "install", package],
+        capture_output=True, text=True,
+    )
+    if result.stdout:
+        click.echo(result.stdout, nl=False)
+    if result.stderr:
+        click.echo(result.stderr, nl=False)
+
+    if result.returncode == 0:
+        combined = result.stdout + result.stderr
+        return True, _parse_vcpkg_version(combined, package)
+    return False, ""
+
+
+def _conan_install(package: str) -> tuple[bool, str]:
+    result = subprocess.run(
+        ["conan", "install", "--requires", package, "--build=missing"],
+        capture_output=True, text=True,
+    )
+    if result.returncode == 0:
+        return True, _parse_conan_version(result.stdout, package)
+    return False, ""
+
+
+def _parse_vcpkg_version(output: str, package: str) -> str:
+    """Parse version from vcpkg output — handles 'fmt:x64-linux@12.1.0' format."""
+    for line in output.splitlines():
+        if package.lower() in line.lower() and "@" in line:
+            return line.strip().split("@")[-1]
+    return "unknown"
+
+
+def _parse_conan_version(output: str, package: str) -> str:
+    base = package.split("/")[0]
+    for line in output.splitlines():
+        if "/" in line and base.lower() in line.lower():
+            return line.strip().split("/")[-1].split("@")[0]
+    return "unknown"

grimx/scaffold.py

@@ -0,0 +1,238 @@
+"""
+grimx.scaffold
+Interactive project creation — create-next-app style.
+"""
+
+from __future__ import annotations
+
+import shutil
+from importlib import resources
+from pathlib import Path
+
+import click
+
+from grimx.config import write_config, write_lock, DEFAULT_CONFIG
+
+TEMPLATE_MAP = {
+    "c":            "c",
+    "cpp":          "cpp",
+    "embedded-c":   "embedded_c",
+    "embedded-cpp": "embedded_cpp",
+}
+
+PROJECT_TYPES  = ["cpp", "c", "embedded-cpp", "embedded-c"]
+CPP_STANDARDS  = ["17", "20", "14"]
+C_STANDARDS    = ["11", "17", "99"]
+MANAGERS       = ["vcpkg", "conan", "both", "none"]
+
+
+def create_project(name: str | None, project_type: str | None) -> None:
+    click.echo("")
+
+    # ── Project name ──────────────────────────────────────────────────────
+    if not name:
+        name = click.prompt("  Project name", default="my_project")
+
+    dest = Path.cwd() / name
+    if dest.exists():
+        click.echo(f"\nerror: directory '{name}' already exists.", err=True)
+        raise SystemExit(1)
+
+    # ── Project type ──────────────────────────────────────────────────────
+    if not project_type:
+        click.echo("")
+        click.echo("  What type of project?")
+        for i, t in enumerate(PROJECT_TYPES, 1):
+            marker = " (default)" if t == "cpp" else ""
+            click.echo(f"    {i}. {t}{marker}")
+        choice = click.prompt("  Choice", default="1", show_default=False)
+        try:
+            project_type = PROJECT_TYPES[int(choice) - 1]
+        except (ValueError, IndexError):
+            project_type = "cpp"
+
+    # ── Language standard ─────────────────────────────────────────────────
+    is_cpp = "cpp" in project_type
+    if is_cpp:
+        standards = CPP_STANDARDS
+        lang      = "C++"
+        default_std = "17"
+    else:
+        standards = C_STANDARDS
+        lang      = "C"
+        default_std = "11"
+
+    click.echo("")
+    click.echo(f"  {lang} standard?")
+    for i, s in enumerate(standards, 1):
+        marker = " (default)" if s == default_std else ""
+        click.echo(f"    {i}. {lang}{s}{marker}")
+    std_choice = click.prompt("  Choice", default="1", show_default=False)
+    try:
+        std = standards[int(std_choice) - 1]
+    except (ValueError, IndexError):
+        std = default_std
+
+    # ── Package manager ───────────────────────────────────────────────────
+    click.echo("")
+    click.echo("  Package manager?")
+    for i, m in enumerate(MANAGERS, 1):
+        marker = " (default)" if m == "vcpkg" else ""
+        click.echo(f"    {i}. {m}{marker}")
+    mgr_choice = click.prompt("  Choice", default="1", show_default=False)
+    try:
+        mgr = MANAGERS[int(mgr_choice) - 1]
+    except (ValueError, IndexError):
+        mgr = "vcpkg"
+
+    if mgr == "both":
+        priority = ["vcpkg", "conan"]
+    elif mgr == "none":
+        priority = []
+    else:
+        priority = [mgr]
+
+    # ── Summary ───────────────────────────────────────────────────────────
+    click.echo("")
+    click.echo(f"  Creating project '{name}'")
+    click.echo(f"    type     : {project_type}")
+    click.echo(f"    standard : {lang}{std}")
+    click.echo(f"    managers : {', '.join(priority) if priority else 'none'}")
+    click.echo("")
+
+    # ── Scaffold ──────────────────────────────────────────────────────────
+    template_src = _get_template_path(TEMPLATE_MAP[project_type])
+    shutil.copytree(template_src, dest)
+
+    for gitkeep in dest.rglob(".gitkeep"):
+        gitkeep.unlink()
+
+    _patch_cmakelists(dest, name, project_type, std)
+    _write_readme(dest, name, project_type, std)
+    _write_gitignore(dest)
+    _write_clang_format(dest)
+
+    # Ensure all expected directories exist
+    for d in ["include", "docs", "cmake"]:
+        (dest / d).mkdir(exist_ok=True)
+
+    write_config({"package_manager": {"priority": priority}}, root=dest)
+    write_lock({"dependencies": {}}, root=dest)
+
+    click.echo(f"  ✓ {dest}")
+    click.echo("")
+    click.echo("  Next steps:")
+    click.echo(f"    cd {name}")
+    if priority:
+        click.echo(f"    grimx install <package>")
+    click.echo(f"    grimx build")
+    click.echo(f"    grimx run")
+    click.echo("")
+
+
+# ---------------------------------------------------------------------------
+# Patching and file generation
+# ---------------------------------------------------------------------------
+
+def _patch_cmakelists(dest: Path, name: str, project_type: str, std: str) -> None:
+    cmake = dest / "CMakeLists.txt"
+    if not cmake.exists():
+        return
+    text = cmake.read_text()
+    is_cpp = "cpp" in project_type
+    text = text.replace("project(PROJECT_NAME", f"project({name}")
+    if is_cpp:
+        text = text.replace("set(CMAKE_CXX_STANDARD 17)", f"set(CMAKE_CXX_STANDARD {std})")
+    else:
+        text = text.replace("set(CMAKE_C_STANDARD 11)", f"set(CMAKE_C_STANDARD {std})")
+    cmake.write_text(text)
+
+
+def _write_readme(dest: Path, name: str, project_type: str, std: str) -> None:
+    is_cpp = "cpp" in project_type
+    lang   = "C++" if is_cpp else "C"
+    content = f"""# {name}
+
+A {lang}{std} project.
+
+## Build
+
+```bash
+grimx build
+grimx test
+grimx run
+```
+
+## Dependencies
+
+Install a dependency:
+
+```bash
+grimx install <package>
+```
+
+Restore from lock file:
+
+```bash
+grimx install
+```
+
+## Project Structure
+
+```
+{name}/
+  src/        source files
+  include/    project headers
+  tests/      unit tests
+  docs/       documentation
+  cmake/      cmake modules
+  CMakeLists.txt
+  grimx.config
+  grimx.lock
+```
+"""
+    (dest / "README.md").write_text(content)
+
+
+def _write_gitignore(dest: Path) -> None:
+    (dest / ".gitignore").write_text(
+        "# Build output\n"
+        "build/\n"
+        "out/\n\n"
+        "# Dependencies\n"
+        "vcpkg_installed/\n"
+        ".conan/\n\n"
+        "# Editor\n"
+        ".vscode/\n"
+        ".idea/\n"
+        "*.swp\n"
+        "*.swo\n\n"
+        "# OS\n"
+        ".DS_Store\n"
+        "Thumbs.db\n\n"
+        "# GRIMX\n"
+        "grimx.lock\n\n"
+    )
+
+
+def _write_clang_format(dest: Path) -> None:
+    (dest / ".clang-format").write_text(
+        "---\n"
+        "BasedOnStyle: LLVM\n"
+        "IndentWidth: 4\n"
+        "ColumnLimit: 100\n"
+        "AllowShortFunctionsOnASingleLine: None\n"
+        "AllowShortIfStatementsOnASingleLine: Never\n"
+        "BreakBeforeBraces: Attach\n"
+        "---\n"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Template resolution
+# ---------------------------------------------------------------------------
+
+def _get_template_path(template_key: str) -> Path:
+    pkg = resources.files("grimx") / "templates" / template_key
+    with resources.as_file(pkg) as path:
+        return Path(str(path)).resolve()

grimx/templates/c/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.20)
+project(PROJECT_NAME C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+include_directories(include)
+
+add_executable(${PROJECT_NAME} src/main.c)
+
+enable_testing()
+add_subdirectory(tests)

grimx/templates/c/tests/CMakeLists.txt

@@ -0,0 +1,4 @@
+# Add test executables here.
+# Example:
+#   add_executable(test_example test_example.c)
+#   add_test(NAME test_example COMMAND test_example)

grimx/templates/cpp/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.20)
+project(PROJECT_NAME CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include_directories(include)
+
+add_executable(${PROJECT_NAME} src/main.cpp)
+
+enable_testing()
+add_subdirectory(tests)

grimx/templates/cpp/src/main.cpp

@@ -0,0 +1,7 @@
+#include <iostream>
+
+int main()
+{
+    std::cout << "Hello from GRIMX!" << std::endl;
+    return 0;
+}

grimx/templates/cpp/tests/CMakeLists.txt

@@ -0,0 +1,4 @@
+# Add test executables here.
+# Example:
+#   add_executable(test_example test_example.cpp)
+#   add_test(NAME test_example COMMAND test_example)

grimx/templates/embedded_c/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.20)
+project(PROJECT_NAME C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+# Toolchain file should be passed via -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain.cmake
+# or configured by GRIMX for the target architecture.
+
+include_directories(include)
+
+add_executable(${PROJECT_NAME} src/main.c)
+
+# enable_testing()
+# add_subdirectory(tests)

grimx/templates/embedded_c/cmake/toolchain.cmake

@@ -0,0 +1,8 @@
+# Toolchain file stub — configure for your target.
+# Example for ARM bare-metal:
+#
+# set(CMAKE_SYSTEM_NAME Generic)
+# set(CMAKE_SYSTEM_PROCESSOR arm)
+# set(CMAKE_C_COMPILER   arm-none-eabi-gcc)
+# set(CMAKE_ASM_COMPILER arm-none-eabi-gcc)
+# set(CMAKE_EXE_LINKER_FLAGS "--specs=nosys.specs" CACHE INTERNAL "")

grimx/templates/embedded_c/src/main.c

@@ -0,0 +1,10 @@
+/* Embedded C entry point
+*  Replace with your target's startup/main conventions as needed.
+*/
+
+void main(void) {
+    /* Application entry */
+    while(1) {
+        /* main loop */
+    }
+}

grimx/templates/embedded_cpp/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.20)
+project(PROJECT_NAME CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Toolchain file should be passed via -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain.cmake
+# or configured by GRIMX for the target architecture.
+
+include_directories(include)
+
+add_executable(${PROJECT_NAME} src/main.cpp)
+
+# Embedded projects commonly disable the standard host test runner.
+# Uncomment and adapt for on-target or emulated testing:
+# enable_testing()
+# add_subdirectory(tests)

grimx/templates/embedded_cpp/cmake/toolchain_cmake

@@ -0,0 +1,9 @@
+# Toolchain file stub — configure for your target.
+# Example for ARM bare-metal:
+#
+# set(CMAKE_SYSTEM_NAME Generic)
+# set(CMAKE_SYSTEM_PROCESSOR arm)
+# set(CMAKE_C_COMPILER   arm-none-eabi-gcc)
+# set(CMAKE_CXX_COMPILER arm-none-eabi-g++)
+# set(CMAKE_ASM_COMPILER arm-none-eabi-gcc)
+# set(CMAKE_EXE_LINKER_FLAGS "--specs=nosys.specs" CACHE INTERNAL "")

grimx/templates/embedded_cpp/src/main.cpp

@@ -0,0 +1,9 @@
+// Embedded C++ entry point 
+// Replace with your target's startup/main conventions needed. 
+
+extern "C" void main() {
+    // Application entry 
+    while(true) {
+        // main loop
+    }
+}

grimx-0.3.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: grimx
+Version: 0.3.0
+Summary: GCC Runtime & Installation Manager, Cross-platform — minimal tooling for C and C++ projects
+License: MIT License
+        
+        Copyright (c) 2026 GRIMX LABS
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: tomlkit>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# GRIMX
+
+**GCC Runtime & Installation Manager - Cross Platform**
+
+A minimal developer tool for reproducible C and C++ environments.
+
+---
+
+## Installation
+
+```bash
+pip install grimx
+```
+
+That's it. The `grimx` command is now available globally.
+
+---
+
+## Quick Start
+
+```bash
+grimx new hello_world
+cd hello_world
+grimx install fmt
+grimx build
+grimx test
+grimx run
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `grimx new <name>` | Scaffold a new project |
+| `grimx new <name> --type c` | Scaffold a C project (default: cpp) |
+| `grimx install <pkg>` | Install a dependency |
+| `grimx install` | Restore all dependencies from lock file |
+| `grimx build` | Build the project via CMake |
+| `grimx test` | Run tests via CTest |
+| `grimx run` | Run the compiled application |
+
+---
+
+## Project Structure
+
+```
+my_project/
+  src/            source files
+  include/        project headers
+  tests/          unit tests
+  cmake/          optional cmake modules
+  CMakeLists.txt
+  grimx.config
+  grimx.lock
+```
+
+---
+
+## Project Types
+
+```bash
+grimx new my_app --type c            # C application
+grimx new my_app --type cpp          # C++ application (default)
+grimx new my_fw  --type embedded-c   # Embedded C
+grimx new my_fw  --type embedded-cpp # Embedded C++
+```
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

grimx-0.3.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+grimx/__init__.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+grimx/build.py,sha256=Mow7T7rRhqqHSaQZpNDAuOHxN_7ws53CdnKbKPDIsKk,3892
+grimx/cli.py,sha256=hUqKPQIlAGlu1HYwEs3fVekiXJBvCXXuuO9UUatiThg,1359
+grimx/config.py,sha256=6iuTRjDWDmiRjNkUl3uriibDVFiBG7tvLzaqQN_WdXs,2230
+grimx/install.py,sha256=WOBOAtBUASILljjoiStJbjimgHz1BeAy7oca2bfuue0,12366
+grimx/scaffold.py,sha256=vvf1x8t8XGFpuWP6M-ur9o-oqLGkYTKrtgcu86aUpHw,7356
+grimx/templates/c/CMakeLists.txt,sha256=VzK4lsdsznER8lnBJYIM0DHtBjKUX7lwFWLAY4Ov0bc,237
+grimx/templates/c/src/main.c,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grimx/templates/c/tests/CMakeLists.txt,sha256=RxBJVDnT9PQ23ttOOi20UBgIavepsarLgyHneo9QZO8,141
+grimx/templates/cpp/CMakeLists.txt,sha256=-ir6f1X6xgnezIj7j0wUEgdX3JrklYoKb58i7aaNsTQ,245
+grimx/templates/cpp/src/main.cpp,sha256=ILaZwjfyq8U5ehM0BQ95adimjtEMrW7JSEUzFdGTJsQ,100
+grimx/templates/cpp/tests/CMakeLists.txt,sha256=AT2xV7W06bjnvp_87XeZMSSk6c08bHSbWE1wnOH9Zso,143
+grimx/templates/embedded_c/CMakeLists.txt,sha256=RjObXGkWA4VURDgggo8opFRZF4BFB2YHLUXRAFICbyE,379
+grimx/templates/embedded_c/cmake/toolchain.cmake,sha256=rKDRleSjz-DJU9t9j75jRyJO_8g2h7z0drUDFdy0n-c,310
+grimx/templates/embedded_c/src/main.c,sha256=wCvnEv7JrqNLvKdU49VKuggF2N5A091lCGH_gizRZz8,188
+grimx/templates/embedded_cpp/CMakeLists.txt,sha256=1C3hPt6awDY8CZgmTKw1JKsew6s6PKr3OSaprBXrIWg,512
+grimx/templates/embedded_cpp/cmake/toolchain_cmake,sha256=rC1wZ4dP5r-5bxqr3G_S8SNe1KkASL5DfffbSp7OwNY,354
+grimx/templates/embedded_cpp/src/main.cpp,sha256=cBS3K1pjglwF_7fMrc6sR32rbFwdCFUP-E7iqQ0xML0,191
+"grimx/templates/embedded_cpp/tests/,gitkeep",sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grimx-0.3.0.dist-info/licenses/LICENSE,sha256=nh_kJ1XfldFWSoUZ2MH8ks8-UiEGLC7ralU72qtsDn4,1067
+grimx-0.3.0.dist-info/METADATA,sha256=_BUVarlQIAUTGXfxCz_S_Myr6WKykVfjP9o7eyn-S4U,3005
+grimx-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+grimx-0.3.0.dist-info/entry_points.txt,sha256=Ql4Ez2SAzxuRDBcEx7sdSeZR-sVOmZgFUFZxDD45TS4,41
+grimx-0.3.0.dist-info/top_level.txt,sha256=l4Om6ZDVTXV6MDxvc-Qo0s045jH-1OOVtv67XVPR_0U,6
+grimx-0.3.0.dist-info/RECORD,,

grimx-0.3.0.dist-info/WHEEL

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

grimx-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+grimx = grimx.cli:main

grimx-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GRIMX LABS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

grimx-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+grimx