implosive-origin-utac 1.0.0__py3-none-any.whl

diamond_setup/__init__.py

@@ -0,0 +1,4 @@
+"""Diamond Setup — universal Python project scaffold."""
+
+__version__ = "1.0.0"
+__author__ = "GenesisAeon"

diamond_setup/_types.py

@@ -0,0 +1,13 @@
+"""Shared type definitions for diamond-setup."""
+
+from typing import TypedDict
+
+
+class TemplateDict(TypedDict):
+    """Structure of a diamond-setup project template."""
+
+    name: str
+    description: str
+    variables: list[str]
+    defaults: dict[str, str]
+    files: dict[str, str]

diamond_setup/cli.py

@@ -0,0 +1,183 @@
+"""Diamond Setup CLI — scaffold, validate and inspect project templates."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from . import __version__
+from .preset import scaffold as _scaffold
+from .templates import REGISTRY
+from .validator import validate as _validate
+
+app = typer.Typer(
+    name="diamond",
+    help="Universal Python project scaffold — create professional skeletons in seconds.",
+    add_completion=True,
+    rich_markup_mode="rich",
+)
+console = Console()
+err_console = Console(stderr=True)
+
+
+# ---------------------------------------------------------------------------
+# scaffold
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def scaffold(
+    project_name: Annotated[
+        str, typer.Argument(help="Name of the new project (kebab-case recommended)")
+    ],
+    template: Annotated[str, typer.Option("--template", "-t", help="Template to use")] = "minimal",
+    output_dir: Annotated[
+        Path | None, typer.Option("--output-dir", "-o", help="Parent directory for the new project")
+    ] = None,
+    author: Annotated[str | None, typer.Option(help="Author name")] = None,
+    description: Annotated[str | None, typer.Option(help="Short project description")] = None,
+    python_version: Annotated[
+        str | None, typer.Option(help="Minimum Python version (e.g. 3.11)")
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview files without writing them")
+    ] = False,
+) -> None:
+    """[bold]Scaffold a new project[/bold] from a template.
+
+    Examples:
+
+      diamond scaffold my-tool
+
+      diamond scaffold my-tool --template genesis --author "Ada Lovelace"
+
+      diamond scaffold my-tool --dry-run
+    """
+    if template not in REGISTRY:
+        err_console.print(
+            f"[red]Unknown template '[bold]{template}[/bold]'. "
+            f"Run [bold]diamond list-templates[/bold] to see available options.[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    dest = output_dir or Path.cwd()
+    project_path = dest / project_name
+
+    if project_path.exists() and not dry_run:
+        err_console.print(
+            f"[red]Directory [bold]{project_path}[/bold] already exists. "
+            "Use a different name or [bold]--output-dir[/bold].[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    overrides = {
+        "author": author,
+        "description": description,
+        "python_version": python_version,
+    }
+
+    tmpl = REGISTRY[template]
+    mode = "[yellow]DRY RUN[/yellow] — " if dry_run else ""
+    console.print(
+        Panel(
+            f"{mode}[bold green]Scaffolding[/bold green] [cyan]{project_name}[/cyan] "
+            f"with template [magenta]{template}[/magenta]",
+            expand=False,
+        )
+    )
+
+    written = _scaffold(project_name, tmpl, dest, overrides=overrides, dry_run=dry_run)
+
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    for path in written:
+        rel = path.relative_to(dest)
+        icon = "📄" if dry_run else "✅"
+        table.add_row(icon, str(rel))
+    console.print(table)
+
+    if dry_run:
+        console.print("\n[yellow]Dry run — no files were written.[/yellow]")
+    else:
+        console.print(
+            f"\n[bold green]Done![/bold green] Project created at [cyan]{project_path}[/cyan]\n"
+            f"\nNext steps:\n"
+            f"  [dim]cd[/dim] {project_name}\n"
+            f"  [dim]uv sync --dev[/dim]\n"
+            f"  [dim]pre-commit install[/dim]\n"
+            f"  [dim]uv run pytest[/dim]"
+        )
+
+
+# ---------------------------------------------------------------------------
+# list-templates
+# ---------------------------------------------------------------------------
+
+
+@app.command(name="list-templates")
+def list_templates() -> None:
+    """List all available templates."""
+    table = Table(title="Available Templates", show_lines=True)
+    table.add_column("Name", style="magenta bold", no_wrap=True)
+    table.add_column("Description")
+    table.add_column("Extra variables", style="dim")
+
+    for name, tmpl in REGISTRY.items():
+        base_vars = {"name", "description", "author", "python_version"}
+        extras = sorted(set(tmpl.get("variables", [])) - base_vars)
+        table.add_row(name, tmpl["description"], ", ".join(extras) or "—")
+
+    console.print(table)
+
+
+# ---------------------------------------------------------------------------
+# validate
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def validate(
+    path: Annotated[Path | None, typer.Argument(help="Project directory to validate")] = None,
+) -> None:
+    """Validate a project directory against diamond-setup best practices."""
+    target = path or Path.cwd()
+    result = _validate(target)
+
+    console.print(f"\nValidating [cyan]{target}[/cyan]\n")
+
+    for msg in result.passed:
+        console.print(f"  [green]✔[/green]  {msg}")
+    for msg in result.warnings:
+        console.print(f"  [yellow]⚠[/yellow]  {msg}")
+    for msg in result.errors:
+        console.print(f"  [red]✘[/red]  {msg}")
+
+    console.print()
+    if result.ok:
+        console.print("[bold green]All checks passed.[/bold green]")
+    else:
+        console.print(f"[bold red]{len(result.errors)} error(s) found.[/bold red]")
+        raise typer.Exit(code=1)
+
+
+# ---------------------------------------------------------------------------
+# version
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def version() -> None:
+    """Show the diamond-setup version."""
+    console.print(f"diamond-setup [bold]{__version__}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    app()

diamond_setup/preset.py

@@ -0,0 +1,84 @@
+"""Preset engine — resolves templates and renders project files."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from string import Template
+
+from ._types import TemplateDict
+
+
+class TemplateError(Exception):
+    """Raised when template rendering fails."""
+
+
+def _to_snake(name: str) -> str:
+    """Convert a project name (kebab or space) to snake_case."""
+    return re.sub(r"[-\s]+", "_", name).lower()
+
+
+def _python_version_nodot(version: str) -> str:
+    """Turn '3.11' into '311' for ruff target-version."""
+    return version.replace(".", "")
+
+
+def _build_context(
+    project_name: str, template: TemplateDict, overrides: dict[str, str | None]
+) -> dict[str, str]:
+    """Merge defaults, user overrides and derived variables into a render context."""
+    ctx: dict[str, str] = {
+        "name": project_name,
+        "name_snake": _to_snake(project_name),
+        **template.get("defaults", {}),
+        **{k: v for k, v in overrides.items() if v is not None},
+    }
+    ctx["python_version_nodot"] = _python_version_nodot(ctx.get("python_version", "3.11"))
+    return ctx
+
+
+def _render(content: str, ctx: dict[str, str]) -> str:
+    """Render a template string using Python's string.Template (safe_substitute)."""
+    # First pass: render path-embedded variables (e.g. ${name_snake} in file keys)
+    return Template(content).safe_substitute(ctx)
+
+
+def scaffold(
+    project_name: str,
+    template: TemplateDict,
+    output_dir: Path,
+    overrides: dict[str, str | None] | None = None,
+    dry_run: bool = False,
+) -> list[Path]:
+    """
+    Render a template into a new project directory.
+
+    Args:
+        project_name: The name of the new project.
+        template:     A template dict from the registry.
+        output_dir:   Parent directory where the project folder will be created.
+        overrides:    Optional variable overrides (e.g. author, description).
+        dry_run:      If True, return planned paths without writing any files.
+
+    Returns:
+        List of paths that were (or would be) written.
+    """
+    overrides = overrides or {}
+    ctx = _build_context(project_name, template, overrides)
+    project_root = output_dir / project_name
+    written: list[Path] = []
+
+    for raw_path, raw_content in template["files"].items():
+        # Render the path itself (e.g. src/${name_snake}/__init__.py)
+        rel_path = Path(_render(raw_path, ctx))
+        abs_path = project_root / rel_path
+
+        rendered_content = _render(raw_content, ctx)
+
+        if not dry_run:
+            abs_path.parent.mkdir(parents=True, exist_ok=True)
+            abs_path.write_text(rendered_content, encoding="utf-8")
+
+        written.append(abs_path)
+
+    return written

diamond_setup/templates/__init__.py

@@ -0,0 +1,15 @@
+"""Template registry — add a new module here to register a new template."""
+
+from diamond_setup._types import TemplateDict
+
+from .genesis import TEMPLATE as GENESIS_TEMPLATE
+from .implosive_origin import TEMPLATE as IMPLOSIVE_ORIGIN_TEMPLATE
+from .minimal import TEMPLATE as MINIMAL_TEMPLATE
+
+REGISTRY: dict[str, TemplateDict] = {
+    "minimal": MINIMAL_TEMPLATE,
+    "genesis": GENESIS_TEMPLATE,
+    "implosive-origin": IMPLOSIVE_ORIGIN_TEMPLATE,
+}
+
+__all__ = ["REGISTRY"]

diamond_setup/templates/genesis.py

@@ -0,0 +1,84 @@
+"""Genesis template — superset of minimal, adds domain/metrics YAML and entropy-table bridge."""
+
+import copy
+
+from diamond_setup._types import TemplateDict
+
+from .minimal import TEMPLATE as MINIMAL_TEMPLATE
+
+_extra_files = {
+    "domains.yaml": """\
+# Domain configuration for ${name}
+# Compatible with entropy-table bridge format
+domains:
+  primary:
+    name: "${name}"
+    metrics: ${metrics}
+    description: "${description}"
+
+relations: []
+
+metadata:
+  project: "${name}"
+  author: "${author}"
+  version: "0.1.0"
+""",
+    "config/entropy.yaml": """\
+# entropy-table bridge configuration
+bridge:
+  source_project: "${name}"
+  export_format: "entropy-table-v1"
+  domains_file: "domains.yaml"
+  output: "exports/entropy-table.yaml"
+
+options:
+  sort_keys: false
+  allow_unicode: true
+""",
+    "src/${name_snake}/bridge.py": """\
+\"\"\"entropy-table YAML bridge for ${name}.\"\"\"
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+
+def export_to_entropy_table(
+    input_path: str | Path = "domains.yaml",
+    output_path: str | Path = "exports/entropy-table.yaml",
+) -> Path:
+    \"\"\"Export domain YAML to entropy-table compatible format.\"\"\"
+    input_path = Path(input_path)
+    output_path = Path(output_path)
+
+    with input_path.open() as f:
+        data = yaml.safe_load(f)
+
+    entropy_data = {
+        "domains": data.get("domains", {}),
+        "relations": data.get("relations", []),
+        "metadata": {
+            **data.get("metadata", {}),
+            "generated_by": "${name} (diamond-setup v1.0.0)",
+        },
+    }
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(yaml.dump(entropy_data, sort_keys=False, allow_unicode=True))
+    return output_path
+""",
+}
+
+_genesis: TemplateDict = copy.deepcopy(MINIMAL_TEMPLATE)
+_genesis["name"] = "genesis"
+_genesis["description"] = "GenesisAeon project with domain/metrics YAML and entropy-table bridge"
+_genesis["variables"] = MINIMAL_TEMPLATE["variables"] + ["metrics"]
+_genesis["defaults"] = {
+    **MINIMAL_TEMPLATE["defaults"],
+    "metrics": "crep",
+}
+_genesis["files"] = {**MINIMAL_TEMPLATE["files"], **_extra_files}
+
+TEMPLATE: TemplateDict = _genesis

diamond_setup/templates/implosive_origin.py

@@ -0,0 +1,87 @@
+"""implosive-origin template — UTAC Type-6 pre-inflationary cosmology scaffold."""
+
+import copy
+
+from diamond_setup._types import TemplateDict
+
+from .genesis import TEMPLATE as GENESIS_TEMPLATE
+
+_extra_files = {
+    "DISCLAIMER.md": """\
+# DISCLAIMER — Speculative Cosmological Module
+
+**Status: SPECULATIVE**
+
+This module implements UTAC Type-6 (Implosive Origin Fields) — a speculative
+cosmological framework. All predictions are hypotheses, not established physics.
+
+See the parent package README for full falsification conditions.
+""",
+    "data/bicep_keck_r_bounds.yaml": """\
+# BICEP/Keck 2021 r < 0.036 — placeholder
+# Replace with actual data from arXiv:2110.00483
+reference: "BICEP/Keck 2021"
+r_upper_95pct: 0.036
+utac_prediction:
+  r_frame_principle: 0.003906
+  status: "SPECULATIVE"
+""",
+    "src/${name_snake}/constants.py": """\
+\"\"\"Physical constants for ${name}.\"\"\"
+import math
+
+PHI: float = (1.0 + math.sqrt(5.0)) / 2.0
+SIGMA_PHI: float = 1.0 / 16.0
+ALPHA: float = 1.0 / 137.035999084
+C_KM_S: float = 299_792.458
+V_RIG_KM_S: float = C_KM_S / (137.035999084 * PHI)
+R_PREDICTED: float = SIGMA_PHI ** 2
+K_RIG_MPC: float = (V_RIG_KM_S / C_KM_S) * 67.4
+""",
+    "src/${name_snake}/type6_ode.py": """\
+\"\"\"UTAC Type-6: reversed logistic ODE.\"\"\"
+import math
+from dataclasses import dataclass
+
+
+@dataclass
+class Type6ODEParams:
+    r: float = 1.0
+    K_min: float = 0.01
+    sigma: float = 0.0625
+    gamma: float = 0.309
+
+
+class Type6ODE:
+    \"\"\"dH/dt = -r·H·(1 - H/K_min)·tanh(σΓ)\"\"\"
+
+    def __init__(self, params: Type6ODEParams | None = None) -> None:
+        self.p = params or Type6ODEParams()
+
+    def dHdt(self, H: float) -> float:
+        return -self.p.r * H * (1.0 - H / self.p.K_min) * math.tanh(self.p.sigma * self.p.gamma)
+
+    def fixed_point(self) -> float:
+        return self.p.K_min * math.tanh(self.p.sigma * self.p.gamma)
+
+    def efolds(self, H0: float = 1.0) -> float:
+        H_star = self.fixed_point()
+        return math.log(H0 / H_star) if H_star > 0 else float("nan")
+""",
+}
+
+_implosive: TemplateDict = copy.deepcopy(GENESIS_TEMPLATE)
+_implosive["name"] = "implosive-origin"
+_implosive["description"] = (
+    "UTAC Type-6 Implosive Origin Fields — pre-inflationary cosmology scaffold "
+    "(GenesisAeon Package 33, SPECULATIVE)"
+)
+_implosive["variables"] = GENESIS_TEMPLATE["variables"] + ["zenodo_doi"]
+_implosive["defaults"] = {
+    **GENESIS_TEMPLATE["defaults"],
+    "metrics": "crep,type6",
+    "zenodo_doi": "10.5281/zenodo.17472834",
+}
+_implosive["files"] = {**GENESIS_TEMPLATE["files"], **_extra_files}
+
+TEMPLATE: TemplateDict = _implosive

diamond_setup/templates/minimal.py

@@ -0,0 +1,171 @@
+"""Minimal template — clean, modern Python project for anyone."""
+
+from diamond_setup._types import TemplateDict
+
+TEMPLATE: TemplateDict = {
+    "name": "minimal",
+    "description": "Clean, modern Python project with uv, ruff, pytest and CI",
+    "variables": ["name", "description", "author", "python_version"],
+    "defaults": {
+        "description": "A Python project",
+        "author": "Your Name",
+        "python_version": "3.11",
+    },
+    "files": {
+        "pyproject.toml": """\
+[project]
+name = "${name}"
+version = "0.1.0"
+description = "${description}"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "${author}" }]
+requires-python = ">=${python_version}"
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["ruff>=0.6.0", "pytest>=8.0.0", "pytest-cov>=5.0.0"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/${name_snake}"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py${python_version_nodot}"
+
+[tool.ruff.lint]
+select = ["E", "F", "B", "I", "W", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=${name_snake} --cov-report=term-missing -v"
+""",
+        "README.md": """\
+# ${name}
+
+${description}
+
+## Quickstart
+
+```bash
+uv sync
+uv run pytest
+```
+
+## Development
+
+```bash
+uv sync --dev
+pre-commit install
+uv run ruff check .
+uv run pytest
+```
+""",
+        ".gitignore": """\
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+.venv/
+.uv/
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+
+# Docs
+site/
+
+# Editors
+.vscode/
+.idea/
+*.swp
+""",
+        ".pre-commit-config.yaml": """\
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.6.0
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+""",
+        ".github/workflows/ci.yml": """\
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: $${{ matrix.python-version }}
+      - run: uv sync --dev
+      - run: uv run ruff check .
+      - run: uv run pytest
+""",
+        "AGENT.md": """\
+# AGENT.md – GenesisAeon Release & Metadata Rules
+
+## Bei jeder relevanten Änderung (Version Bump, Feature, Bugfix, Docs):
+
+1. **.zenodo.json**
+   - Aktualisiere `version`, `description`, `keywords`, `related_identifiers`
+   - Beschreibung muss die aktuelle Funktion des Packages klar beschreiben
+   - Immer den Whitepaper-DOI (10.5281/zenodo.19645351) als `isPartOf` oder
+     `isDocumentedBy` eintragen
+
+2. **README.md**
+   - Aktualisiere Whitepaper-Badge auf aktuelle Version
+   - Aktualisiere @software BibTeX-Eintrag (version, publisher=Zenodo, DOI)
+   - Füge Package-Number-Badge ein (z.B. Package 17)
+
+3. **Versionierung**
+   - pyproject.toml und __init__.py müssen synchron auf dieselbe Version sein
+   - Tags immer als annotated Tag (`git tag -a vX.Y.Z`)
+
+4. **Commit-Message**
+   - Beginne mit "release:", "feat:", "fix:", "docs:" oder "chore:"
+
+5. **Nach jedem neuen Tag**
+   - Release-Pipeline (PyPI + Zenodo) wird automatisch ausgelöst
+
+Diese Regeln sind bindend für alle Claude-Code-Runs und zukünftige Agents in GenesisAeon-Repos.
+""",
+        "src/${name_snake}/__init__.py": ('"""${name}."""\n\n__version__ = "0.1.0"\n'),
+        "tests/__init__.py": "",
+        "tests/test_main.py": """\
+\"\"\"Tests for ${name}.\"\"\"
+
+from ${name_snake} import __version__
+
+
+def test_version():
+    assert __version__ == "0.1.0"
+""",
+    },
+}