decklens 0.1.0__py3-none-any.whl

decklens/__init__.py

@@ -0,0 +1,3 @@
+"""DeckLens Semantic Diff for CAE — OpenRadioss input file analysis."""
+
+__version__ = "0.1.0"

decklens/cli.py

@@ -0,0 +1,199 @@
+"""CLI entry point for DeckLens Semantic Diff."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import click
+from rich.columns import Columns
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .diff.engine import Change, DiffEngine
+from .parsers.openradioss import parse_deck
+
+def _make_console() -> Console:
+    import sys
+    if sys.platform == "win32":
+        try:
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+        except (AttributeError, Exception):
+            pass
+    return Console(highlight=False, safe_box=True)
+
+
+console = _make_console()
+
+_SEVERITY_STYLE = {
+    "CRITICAL": "bold red",
+    "WARNING":  "bold yellow",
+    "INFO":     "cyan",
+}
+_SEVERITY_LABEL = {
+    "CRITICAL": "CRIT",
+    "WARNING":  "WARN",
+    "INFO":     "INFO",
+}
+
+
+def _fmt_value(v, unit: str | None) -> str:
+    if v is None:
+        return "-"
+    u = f" {unit}" if unit else ""
+    if isinstance(v, float):
+        return f"{v:g}{u}"
+    return f"{v}{u}"
+
+
+def _pct_text(pct: float | None) -> Text:
+    if pct is None:
+        return Text("")
+    sign = "+" if pct > 0 else ""
+    color = "red" if abs(pct) >= 20 else "yellow" if abs(pct) >= 5 else "green"
+    return Text(f"{sign}{pct:.1f}%", style=color)
+
+
+def _build_table(changes: list[Change]) -> Table:
+    table = Table(
+        show_header=True,
+        header_style="bold white on dark_blue",
+        border_style="bright_black",
+        safe_box=True,
+    )
+    table.add_column("Sev",       style="bold",  no_wrap=True)
+    table.add_column("Category",  no_wrap=True)
+    table.add_column("Type / ID", no_wrap=True)
+    table.add_column("Name")
+    table.add_column("Field",     ratio=2)
+    table.add_column("Before",    justify="right", no_wrap=True)
+    table.add_column("After",     justify="right", no_wrap=True)
+    table.add_column("Change",    justify="right", no_wrap=True)
+
+    for ch in changes:
+        style = _SEVERITY_STYLE[ch.severity]
+        icon = Text("[" + _SEVERITY_LABEL[ch.severity] + "]", style=style)
+        table.add_row(
+            icon,
+            Text(ch.category, style="dim"),
+            Text(f"{ch.item_type}/{ch.item_id}", style="bright_white"),
+            Text(str(ch.item_name), style="white"),
+            Text(str(ch.field)),
+            Text(_fmt_value(ch.old_value, None)),
+            Text(_fmt_value(ch.new_value, ch.unit)),
+            _pct_text(ch.percent_change),
+        )
+
+    return table
+
+
+def _build_summary(changes: list[Change]) -> Panel:
+    counts = {"CRITICAL": 0, "WARNING": 0, "INFO": 0}
+    for ch in changes:
+        counts[ch.severity] += 1
+
+    parts = []
+    for sev in ("CRITICAL", "WARNING", "INFO"):
+        n = counts[sev]
+        style = _SEVERITY_STYLE[sev]
+        parts.append(Text(f"  {n} {sev}  ", style=style))
+
+    content = Text("").join(parts)
+    return Panel(content, title="[bold]Summary", expand=False)
+
+
+@click.group()
+@click.version_option(package_name="DeckLens-Semantic-Diff-for-CAE")
+def main() -> None:
+    """DeckLens: Semantic Diff for CAE input files."""
+
+
+@main.command()
+@click.argument("before", type=click.Path(exists=True, path_type=Path))
+@click.argument("after", type=click.Path(exists=True, path_type=Path))
+@click.option("--no-ai", is_flag=True, default=False, help="Skip Claude AI analysis.")
+@click.option(
+    "--format", "output_format",
+    type=click.Choice(["text", "json"], case_sensitive=False),
+    default="text",
+    help="Output format.",
+)
+@click.option("--model", default="claude-opus-4-8", show_default=True,
+              help="Claude model ID for AI analysis.")
+@click.option("--min-severity",
+              type=click.Choice(["INFO", "WARNING", "CRITICAL"], case_sensitive=False),
+              default="INFO", show_default=True,
+              help="Minimum severity level to display.")
+def diff(
+    before: Path,
+    after: Path,
+    no_ai: bool,
+    output_format: str,
+    model: str,
+    min_severity: str,
+) -> None:
+    """Compare two OpenRadioss deck files and show engineering-aware changes.
+
+    BEFORE and AFTER are paths to .rad input files.
+    """
+    _sev_rank = {"INFO": 0, "WARNING": 1, "CRITICAL": 2}
+    min_rank = _sev_rank[min_severity.upper()]
+
+    # Parse
+    with console.status("[bold green]Parsing decks...", spinner="dots"):
+        try:
+            deck_before = parse_deck(before)
+            deck_after = parse_deck(after)
+        except Exception as exc:
+            console.print(f"[red]Parse error: {exc}")
+            sys.exit(1)
+
+    # Diff
+    engine = DiffEngine()
+    all_changes = engine.diff(deck_before, deck_after)
+    changes = [ch for ch in all_changes if _sev_rank[ch.severity] >= min_rank]
+
+    if output_format == "json":
+        import dataclasses
+        click.echo(json.dumps([dataclasses.asdict(ch) for ch in changes], indent=2))
+        return
+
+    # Rich text output
+    console.print()
+    console.rule(f"[bold blue]DeckLens Semantic Diff")
+    console.print(f"  [dim]Before:[/dim] [white]{before}")
+    console.print(f"  [dim]After: [/dim] [white]{after}")
+    console.print()
+
+    if not changes:
+        console.print("[green]No changes found above the specified severity threshold.[/green]")
+        return
+
+    console.print(_build_summary(all_changes))
+    console.print()
+    console.print(_build_table(changes))
+
+    # AI analysis
+    if not no_ai:
+        try:
+            from dotenv import load_dotenv
+            load_dotenv()
+        except ImportError:
+            pass
+
+        import os
+        if not os.environ.get("ANTHROPIC_API_KEY"):
+            console.print(
+                "\n[yellow]Tip: Set ANTHROPIC_API_KEY in .env for AI analysis. "
+                "Use --no-ai to suppress this message.[/yellow]"
+            )
+            return
+
+        from .explainer.claude import ClaudeExplainer
+        with console.status("[bold green]Generating AI analysis...", spinner="dots"):
+            explainer = ClaudeExplainer(model=model)
+        explainer.explain(changes, str(before), str(after), console=console)

decklens/diff/__init__.py

@@ -0,0 +1,3 @@
+from .engine import Change, DiffEngine
+
+__all__ = ["Change", "DiffEngine"]

decklens/diff/engine.py

@@ -0,0 +1,472 @@
+"""Semantic diff engine: compares two Deck objects and returns engineering-aware Changes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..parsers.base import (
+    BoundaryCondition,
+    Contact,
+    Deck,
+    Load,
+    Material,
+    Part,
+    ShellProperty,
+    SolidProperty,
+)
+
+# Thresholds (WARNING%, CRITICAL%) per field name
+_THRESHOLDS: dict[str, tuple[float, float]] = {
+    "thickness": (5.0, 20.0),
+    "Thick":     (5.0, 20.0),
+    "E":         (1.5, 10.0),
+    "nu":        (5.0, 15.0),
+    "yield_stress": (5.0, 15.0),
+    "a":         (5.0, 15.0),   # J-C yield stress
+    "Rho_Init":  (5.0, 20.0),
+    "rho":       (5.0, 20.0),
+    "Fscale_y":  (10.0, 50.0),  # load magnitude
+    "Stfac":     (10.0, 30.0),  # contact stiffness
+    "Fric":      (10.0, 30.0),  # friction coefficient
+    "gap_min":   (10.0, 30.0),
+}
+
+_SEVERITY_ORDER = ("CRITICAL", "WARNING", "INFO")
+
+
+@dataclass
+class Change:
+    category: str       # MATERIAL | PROPERTY | PART | BOUNDARY | LOAD | CONTACT | MESH | TOPOLOGY
+    item_type: str      # e.g. "MAT/ELAST", "PROP/SHELL"
+    item_id: int | str
+    item_name: str
+    field: str
+    old_value: Any
+    new_value: Any
+    unit: str | None = None
+    percent_change: float | None = None
+    severity: str = "INFO"   # INFO | WARNING | CRITICAL
+
+
+def _pct(old: float, new: float) -> float | None:
+    if old == 0.0:
+        return None
+    return (new - old) / abs(old) * 100.0
+
+
+def _severity(field: str, pct: float | None) -> str:
+    if pct is None:
+        return "WARNING"
+    warn, crit = _THRESHOLDS.get(field, (5.0, 20.0))
+    abs_pct = abs(pct)
+    if abs_pct >= crit:
+        return "CRITICAL"
+    if abs_pct >= warn:
+        return "WARNING"
+    return "INFO"
+
+
+def _float_change(
+    category: str,
+    item_type: str,
+    item_id: int,
+    item_name: str,
+    field: str,
+    old: float | None,
+    new: float | None,
+    unit: str | None = None,
+) -> Change | None:
+    if old is None and new is None:
+        return None
+    if old == new:
+        return None
+    pct = _pct(old, new) if (old is not None and new is not None) else None
+    sev = _severity(field, pct)
+    return Change(
+        category=category,
+        item_type=item_type,
+        item_id=item_id,
+        item_name=item_name,
+        field=field,
+        old_value=old,
+        new_value=new,
+        unit=unit,
+        percent_change=pct,
+        severity=sev,
+    )
+
+
+class DiffEngine:
+    def diff(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        changes.extend(self._diff_materials(before, after))
+        changes.extend(self._diff_shell_props(before, after))
+        changes.extend(self._diff_solid_props(before, after))
+        changes.extend(self._diff_parts(before, after))
+        changes.extend(self._diff_bcs(before, after))
+        changes.extend(self._diff_loads(before, after))
+        changes.extend(self._diff_contacts(before, after))
+        changes.extend(self._diff_mesh(before, after))
+        # Sort: CRITICAL first, then WARNING, then INFO
+        changes.sort(key=lambda c: _SEVERITY_ORDER.index(c.severity))
+        return changes
+
+    # ------------------------------------------------------------------
+    # Materials
+    # ------------------------------------------------------------------
+
+    def _diff_materials(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        all_ids = set(before.materials) | set(after.materials)
+
+        for mid in sorted(all_ids):
+            b = before.materials.get(mid)
+            a = after.materials.get(mid)
+
+            if b is None:
+                changes.append(Change(
+                    category="MATERIAL", item_type=f"MAT/{a.law}",
+                    item_id=mid, item_name=a.name,
+                    field="[added]", old_value=None, new_value=a.name,
+                    severity="WARNING",
+                ))
+                continue
+            if a is None:
+                changes.append(Change(
+                    category="MATERIAL", item_type=f"MAT/{b.law}",
+                    item_id=mid, item_name=b.name,
+                    field="[removed]", old_value=b.name, new_value=None,
+                    severity="CRITICAL",
+                ))
+                continue
+
+            item_type = f"MAT/{b.law}"
+            name = b.name
+
+            for fld, unit in [("E", "MPa"), ("nu", None), ("rho", "Mg/mm³"), ("yield_stress", "MPa")]:
+                bv = getattr(b, fld)
+                av = getattr(a, fld)
+                c = _float_change("MATERIAL", item_type, mid, name, fld, bv, av, unit)
+                if c:
+                    changes.append(c)
+
+            # Extra raw fields for plasticity laws
+            if b.law in ("PLAS_JOHNS", "PLAS_ZERIL"):
+                for fld, unit in [("b", "MPa"), ("n", None), ("c", None)]:
+                    bv = b.raw_fields.get(fld)
+                    av = a.raw_fields.get(fld)
+                    c = _float_change("MATERIAL", item_type, mid, name, fld, bv, av, unit)
+                    if c:
+                        changes.append(c)
+
+        return changes
+
+    # ------------------------------------------------------------------
+    # Shell properties
+    # ------------------------------------------------------------------
+
+    def _diff_shell_props(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        all_ids = set(before.shell_props) | set(after.shell_props)
+
+        for pid in sorted(all_ids):
+            b = before.shell_props.get(pid)
+            a = after.shell_props.get(pid)
+
+            if b is None:
+                changes.append(Change(
+                    category="PROPERTY", item_type="PROP/SHELL",
+                    item_id=pid, item_name=a.name,
+                    field="[added]", old_value=None, new_value=a.name,
+                    severity="WARNING",
+                ))
+                continue
+            if a is None:
+                changes.append(Change(
+                    category="PROPERTY", item_type="PROP/SHELL",
+                    item_id=pid, item_name=b.name,
+                    field="[removed]", old_value=b.name, new_value=None,
+                    severity="CRITICAL",
+                ))
+                continue
+
+            c = _float_change("PROPERTY", "PROP/SHELL", pid, b.name, "thickness", b.thickness, a.thickness, "mm")
+            if c:
+                # Annotate bending stiffness impact: EI ∝ t³
+                if c.percent_change is not None and b.thickness and a.thickness:
+                    ratio = a.thickness / b.thickness
+                    stiffness_pct = (ratio ** 3 - 1.0) * 100.0
+                    c.field = f"thickness (bend-stiffness {stiffness_pct:+.1f}%)"
+                changes.append(c)
+
+            if b.ishell != a.ishell and a.ishell is not None:
+                changes.append(Change(
+                    category="PROPERTY", item_type="PROP/SHELL",
+                    item_id=pid, item_name=b.name,
+                    field="Ishell (formulation)",
+                    old_value=b.ishell, new_value=a.ishell,
+                    severity="WARNING",
+                ))
+
+        return changes
+
+    # ------------------------------------------------------------------
+    # Solid properties
+    # ------------------------------------------------------------------
+
+    def _diff_solid_props(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        all_ids = set(before.solid_props) | set(after.solid_props)
+
+        for pid in sorted(all_ids):
+            b = before.solid_props.get(pid)
+            a = after.solid_props.get(pid)
+
+            if b is None:
+                changes.append(Change(
+                    category="PROPERTY", item_type="PROP/SOLID",
+                    item_id=pid, item_name=a.name,
+                    field="[added]", old_value=None, new_value=a.name,
+                    severity="INFO",
+                ))
+            elif a is None:
+                changes.append(Change(
+                    category="PROPERTY", item_type="PROP/SOLID",
+                    item_id=pid, item_name=b.name,
+                    field="[removed]", old_value=b.name, new_value=None,
+                    severity="CRITICAL",
+                ))
+            elif b.isolid != a.isolid:
+                changes.append(Change(
+                    category="PROPERTY", item_type="PROP/SOLID",
+                    item_id=pid, item_name=b.name,
+                    field="Isolid (formulation)",
+                    old_value=b.isolid, new_value=a.isolid,
+                    severity="WARNING",
+                ))
+
+        return changes
+
+    # ------------------------------------------------------------------
+    # Parts
+    # ------------------------------------------------------------------
+
+    def _diff_parts(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        all_ids = set(before.parts) | set(after.parts)
+
+        for pid in sorted(all_ids):
+            b = before.parts.get(pid)
+            a = after.parts.get(pid)
+
+            if b is None:
+                changes.append(Change(
+                    category="PART", item_type="PART",
+                    item_id=pid, item_name=a.name,
+                    field="[added]", old_value=None, new_value=a.name,
+                    severity="INFO",
+                ))
+                continue
+            if a is None:
+                changes.append(Change(
+                    category="PART", item_type="PART",
+                    item_id=pid, item_name=b.name,
+                    field="[removed]", old_value=b.name, new_value=None,
+                    severity="CRITICAL",
+                ))
+                continue
+
+            if b.mat_id != a.mat_id:
+                changes.append(Change(
+                    category="PART", item_type="PART",
+                    item_id=pid, item_name=b.name,
+                    field="mat_ID",
+                    old_value=b.mat_id, new_value=a.mat_id,
+                    severity="CRITICAL",
+                ))
+            if b.prop_id != a.prop_id:
+                changes.append(Change(
+                    category="PART", item_type="PART",
+                    item_id=pid, item_name=b.name,
+                    field="prop_ID",
+                    old_value=b.prop_id, new_value=a.prop_id,
+                    severity="CRITICAL",
+                ))
+
+        return changes
+
+    # ------------------------------------------------------------------
+    # Boundary conditions
+    # ------------------------------------------------------------------
+
+    def _diff_bcs(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        all_ids = set(before.bcs) | set(after.bcs)
+        dofs = ["tx", "ty", "tz", "rx", "ry", "rz"]
+
+        for bid in sorted(all_ids):
+            b = before.bcs.get(bid)
+            a = after.bcs.get(bid)
+
+            if b is None:
+                changes.append(Change(
+                    category="BOUNDARY", item_type="BCS",
+                    item_id=bid, item_name=a.name,
+                    field="[added]", old_value=None, new_value=a.name,
+                    severity="WARNING",
+                ))
+                continue
+            if a is None:
+                changes.append(Change(
+                    category="BOUNDARY", item_type="BCS",
+                    item_id=bid, item_name=b.name,
+                    field="[removed]", old_value=b.name, new_value=None,
+                    severity="CRITICAL",
+                ))
+                continue
+
+            for dof in dofs:
+                bv = getattr(b, dof)
+                av = getattr(a, dof)
+                if bv != av:
+                    changes.append(Change(
+                        category="BOUNDARY", item_type="BCS",
+                        item_id=bid, item_name=b.name,
+                        field=dof.upper(),
+                        old_value="fixed" if bv else "free",
+                        new_value="fixed" if av else "free",
+                        severity="CRITICAL" if not av else "WARNING",
+                    ))
+
+        return changes
+
+    # ------------------------------------------------------------------
+    # Loads
+    # ------------------------------------------------------------------
+
+    def _diff_loads(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        all_ids = set(before.loads) | set(after.loads)
+
+        for lid in sorted(all_ids):
+            b = before.loads.get(lid)
+            a = after.loads.get(lid)
+
+            if b is None:
+                changes.append(Change(
+                    category="LOAD", item_type=a.load_type,
+                    item_id=lid, item_name=a.name,
+                    field="[added]", old_value=None, new_value=a.name,
+                    severity="WARNING",
+                ))
+                continue
+            if a is None:
+                changes.append(Change(
+                    category="LOAD", item_type=b.load_type,
+                    item_id=lid, item_name=b.name,
+                    field="[removed]", old_value=b.name, new_value=None,
+                    severity="CRITICAL",
+                ))
+                continue
+
+            item_type = b.load_type
+
+            # CLOAD: compare direction and magnitude scaling
+            if item_type == "CLOAD":
+                bdir = b.raw_fields.get("Dir")
+                adir = a.raw_fields.get("Dir")
+                if bdir != adir:
+                    changes.append(Change(
+                        category="LOAD", item_type="CLOAD",
+                        item_id=lid, item_name=b.name,
+                        field="Dir",
+                        old_value=bdir, new_value=adir,
+                        severity="CRITICAL",
+                    ))
+                c = _float_change("LOAD", "CLOAD", lid, b.name, "Fscale_y",
+                                  b.raw_fields.get("Fscale_y"), a.raw_fields.get("Fscale_y"), "N")
+                if c:
+                    changes.append(c)
+
+            elif item_type == "GRAV":
+                for ax in ("gx", "gy", "gz"):
+                    c = _float_change("LOAD", "GRAV", lid, b.name, ax,
+                                      b.raw_fields.get(ax), a.raw_fields.get(ax), "mm/s²")
+                    if c:
+                        changes.append(c)
+
+            elif item_type == "PRESSURE":
+                c = _float_change("LOAD", "PRESSURE", lid, b.name, "Fscale_P",
+                                  b.raw_fields.get("Fscale_P"), a.raw_fields.get("Fscale_P"), "MPa")
+                if c:
+                    changes.append(c)
+
+        return changes
+
+    # ------------------------------------------------------------------
+    # Contacts
+    # ------------------------------------------------------------------
+
+    def _diff_contacts(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+        all_ids = set(before.contacts) | set(after.contacts)
+
+        for cid in sorted(all_ids):
+            b = before.contacts.get(cid)
+            a = after.contacts.get(cid)
+
+            if b is None:
+                changes.append(Change(
+                    category="CONTACT", item_type=f"INTER/{a.contact_type}",
+                    item_id=cid, item_name=a.name,
+                    field="[added]", old_value=None, new_value=a.name,
+                    severity="WARNING",
+                ))
+                continue
+            if a is None:
+                changes.append(Change(
+                    category="CONTACT", item_type=f"INTER/{b.contact_type}",
+                    item_id=cid, item_name=b.name,
+                    field="[removed]", old_value=b.name, new_value=None,
+                    severity="CRITICAL",
+                ))
+                continue
+
+            item_type = f"INTER/{b.contact_type}"
+            for fld, unit in [("Stfac", None), ("Fric", None), ("gap_min", "mm"), ("gap_max", "mm")]:
+                c = _float_change("CONTACT", item_type, cid, b.name, fld,
+                                  b.raw_fields.get(fld), a.raw_fields.get(fld), unit)
+                if c:
+                    changes.append(c)
+
+        return changes
+
+    # ------------------------------------------------------------------
+    # Mesh topology
+    # ------------------------------------------------------------------
+
+    def _diff_mesh(self, before: Deck, after: Deck) -> list[Change]:
+        changes: list[Change] = []
+
+        for attr, label, unit in [
+            ("node_count", "node_count", "nodes"),
+            ("shell_count", "shell_count", "elements"),
+            ("solid_count", "solid_count", "elements"),
+        ]:
+            bv = getattr(before, attr)
+            av = getattr(after, attr)
+            if bv == av:
+                continue
+            pct = _pct(bv, av) if bv else None
+            changes.append(Change(
+                category="MESH", item_type="MESH",
+                item_id=0, item_name="mesh",
+                field=label,
+                old_value=bv, new_value=av,
+                unit=unit,
+                percent_change=pct,
+                severity="WARNING" if pct and abs(pct) >= 10.0 else "INFO",
+            ))
+
+        return changes

decklens/explainer/__init__.py

@@ -0,0 +1,3 @@
+from .claude import ClaudeExplainer
+
+__all__ = ["ClaudeExplainer"]