asecli 0.6.2__py3-none-any.whl

asecli/core/fishbone_topology.py

@@ -0,0 +1,186 @@
+"""Build the deterministic primary tree used by recursive fishbone layout."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Mapping, Protocol
+
+from .commentary import COMMENTARY_TYPE
+from .layout import MASTER_TYPES
+from .layout_graph import (
+    graph_depths, has_incoming, id_key, immediate_comment_owners, is_master,
+    node_position, port_key, reject_cycles,
+)
+from .local_vars import REGISTER_LOCAL_VAR_TYPE
+from .model import AseGraph, WireLine
+from .wire_router import WIRE_NODE_TYPE, logical_wires
+
+
+class Geometry(Protocol):
+    width: float
+    height: float
+    title_height: float
+    input_ports: dict[str, tuple[float, float]]
+    output_ports: dict[str, tuple[float, float]]
+
+
+@dataclass
+class FishboneTopology:
+    ids: set[str]
+    types: dict[str, str]
+    collapsed_wires: list[WireLine]
+    satellites: set[str]
+    depths: dict[str, int]
+    group_of: dict[str, str]
+    current_y: dict[str, float]
+    primary_parent: dict[str, str]
+    primary_wire: dict[tuple[str, str], WireLine]
+    children: dict[str, tuple[str, ...]]
+    spine_child: dict[str, str]
+    roots: list[str]
+
+
+def build_fishbone_topology(graph: AseGraph, geometry: Mapping[str, Geometry]) -> FishboneTopology:
+    candidates = [
+        node for node in graph.nodes
+        if node.type_name not in {COMMENTARY_TYPE, WIRE_NODE_TYPE}
+    ]
+    collapsed = [item.wire for item in logical_wires(graph)]
+    connected = {node_id for wire in collapsed for node_id in (wire.out_node, wire.in_node)}
+    unavailable = {
+        node.node_id for node in candidates
+        if node.node_id not in geometry
+        or geometry[node.node_id].width <= 0
+        or geometry[node.node_id].height <= 0
+        or geometry[node.node_id].title_height <= 0
+    }
+    dormant = {
+        node.node_id for node in candidates
+        if node.node_id in unavailable and node.type_name in MASTER_TYPES
+        and node.node_id not in connected
+    }
+    missing = sorted(unavailable - dormant, key=id_key)
+    if missing:
+        raise ValueError(f"editor geometry missing active node(s): {', '.join(missing)}")
+    nodes = [node for node in candidates if node.node_id not in dormant]
+    ids = {node.node_id for node in nodes}
+    types = {node.node_id: node.type_name for node in nodes}
+    _require_logical_ports(collapsed, ids, geometry)
+
+    physical: dict[str, list[WireLine]] = defaultdict(list)
+    for wire in collapsed:
+        if wire.out_node in ids and wire.in_node in ids and wire.out_node != wire.in_node:
+            physical[wire.out_node].append(wire)
+    satellites = {
+        node_id for node_id in ids
+        if types[node_id] == REGISTER_LOCAL_VAR_TYPE and not physical.get(node_id)
+        and any(wire.in_node == node_id for wire in collapsed)
+    }
+    outgoing: dict[str, list[WireLine]] = defaultdict(list)
+    for source, wires in physical.items():
+        outgoing[source].extend(wire for wire in wires if wire.in_node not in satellites)
+    reject_cycles(ids, outgoing)
+    depths = graph_depths(ids, outgoing)
+    group_of = immediate_comment_owners(graph)
+    current_y = {node.node_id: node_position(node)[1] for node in nodes}
+    primary_parent, primary_wire = _choose_primary(
+        ids, outgoing, depths, group_of, current_y,
+    )
+    children_lists: dict[str, list[str]] = defaultdict(list)
+    for child, parent in primary_parent.items():
+        children_lists[parent].append(child)
+    for parent, members in children_lists.items():
+        members.sort(key=lambda child: (
+            port_key(primary_wire[(child, parent)].in_port), current_y[child], id_key(child),
+        ))
+    children = {node_id: tuple(children_lists.get(node_id, [])) for node_id in ids}
+    upstream_depth, upstream_size = _measure_topology(ids, children)
+    spine_child = _choose_spines(
+        children, primary_wire, geometry, upstream_depth, upstream_size, current_y,
+    )
+    roots = [item for item in ids if item not in primary_parent and item not in satellites]
+    roots.sort(key=lambda item: (
+        0 if is_master(graph, item) else 1,
+        0 if outgoing.get(item) or has_incoming(graph, item) else 1,
+        id_key(item),
+    ))
+    if not roots:
+        raise ValueError("meticulous layout found no root node")
+    return FishboneTopology(
+        ids, types, collapsed, satellites, depths, group_of, current_y,
+        primary_parent, primary_wire, children, spine_child, roots,
+    )
+
+
+def _choose_primary(ids, outgoing, depths, group_of, current_y):
+    parents, wires = {}, {}
+    for source in sorted(ids, key=id_key):
+        choices = outgoing.get(source, [])
+        if not choices:
+            continue
+        chosen = min(choices, key=lambda wire: (
+            -depths[wire.in_node],
+            0 if group_of.get(source) == group_of.get(wire.in_node) else 1,
+            port_key(wire.in_port), abs(current_y[source] - current_y[wire.in_node]),
+            id_key(wire.in_node),
+        ))
+        parents[source] = chosen.in_node
+        wires[(source, chosen.in_node)] = chosen
+    return parents, wires
+
+
+def _measure_topology(ids, children):
+    depths, sizes = {}, {}
+
+    def measure(node_id):
+        if node_id in depths:
+            return depths[node_id], sizes[node_id]
+        branch = children[node_id]
+        values = [measure(child) for child in branch]
+        depths[node_id] = 0 if not values else 1 + max(item[0] for item in values)
+        sizes[node_id] = 1 + sum(item[1] for item in values)
+        return depths[node_id], sizes[node_id]
+
+    for node_id in sorted(ids, key=id_key):
+        measure(node_id)
+    return depths, sizes
+
+
+def _choose_spines(children, primary_wire, geometry, depths, sizes, current_y):
+    result = {}
+    for parent, branch in children.items():
+        if not branch:
+            continue
+        if len(branch) >= 3 and len(branch) % 2 == 1:
+            result[parent] = branch[len(branch) // 2]
+            continue
+        candidates = branch[len(branch) // 2 - 1: len(branch) // 2 + 1] if len(branch) >= 4 else branch
+        result[parent] = max(candidates, key=lambda child: _spine_score(
+            child, parent, primary_wire[(child, parent)], geometry, depths, sizes, current_y,
+        ))
+    return result
+
+
+def _spine_score(child, parent, wire, geometry, depths, sizes, current_y):
+    label = str((getattr(geometry[parent], "input_port_labels", {}) or {}).get(wire.in_port, "")).lower()
+    control = ("strength", "amount", "softness", "saturation", "threshold", "scale")
+    data = ("input", "value", "color", "normal", "reflection", "true")
+    semantic = -1 if any(word in label for word in control) else int(any(word in label for word in data))
+    delta = abs(
+        current_y[child] + geometry[child].output_ports[wire.out_port][1]
+        - current_y[parent] - geometry[parent].input_ports[wire.in_port][1]
+    )
+    numeric_port = port_key(wire.in_port)
+    port_rank = -float(numeric_port[1]) if numeric_port[0] == 0 else 0.0
+    return depths[child], int(sizes[child] > 1), semantic, sizes[child], -delta, port_rank
+
+
+def _require_logical_ports(wires, ids, geometry):
+    for wire in wires:
+        if wire.out_node not in ids or wire.in_node not in ids:
+            continue
+        if wire.out_port not in geometry[wire.out_node].output_ports:
+            raise ValueError(f"editor geometry missing output port {wire.out_node}:{wire.out_port}")
+        if wire.in_port not in geometry[wire.in_node].input_ports:
+            raise ValueError(f"editor geometry missing input port {wire.in_node}:{wire.in_port}")

asecli/core/graph_ops.py

@@ -0,0 +1,122 @@
+"""Graph mutation operations (TASK-0007)."""
+
+from __future__ import annotations
+
+from .model import AseGraph, NodeLine, WireLine
+from .local_vars import GET_LOCAL_VAR_TYPE, REGISTER_LOCAL_VAR_TYPE, parse_get_local_var
+
+
+def set_node_field(graph: AseGraph, node_id: str, field_index: int, value: str) -> NodeLine:
+    """Set one serialized field of a node by absolute index (0 = 'Node' marker)."""
+    if field_index in {0, 1, 2}:
+        raise ValueError(
+            "fields 0-2 are structural (marker/type/id) and cannot be changed with set-field"
+        )
+    node = graph.node_by_id(node_id)
+    if node is None:
+        raise KeyError(f"node {node_id} not found")
+    if not 0 <= field_index < len(node.raw_fields):
+        raise IndexError(f"field index {field_index} out of range (node has {len(node.raw_fields)} fields)")
+    node.raw_fields[field_index] = value
+    graph.replace_node(node)
+    return node
+
+
+def remove_node(graph: AseGraph, node_id: str) -> int:
+    """Remove a node and every wire touching it. Returns removed wire count."""
+    target = graph.node_by_id(node_id)
+    if target is None:
+        raise KeyError(f"node {node_id} not found")
+    if target.type_name == REGISTER_LOCAL_VAR_TYPE:
+        references = []
+        for node in graph.nodes:
+            if node.type_name != GET_LOCAL_VAR_TYPE:
+                continue
+            try:
+                if parse_get_local_var(node)["register_id"] == node_id:
+                    references.append(node.node_id)
+            except ValueError:
+                continue
+        if references:
+            rendered = ", ".join(sorted(references, key=_node_id_sort_key))
+            raise ValueError(f"RegisterLocalVarNode {node_id} is referenced by Get nodes: {rendered}")
+    removed_wires = 0
+    for i in reversed(range(len(graph.instructions))):
+        kind, raw = graph.instructions[i]
+        if kind == "wire":
+            w = _parse_wire(raw)
+            if w.in_node == node_id or w.out_node == node_id:
+                graph.delete_instruction(i)
+                removed_wires += 1
+    for i, (kind, raw) in enumerate(graph.instructions):
+        if kind == "node" and _parse_node(raw).node_id == node_id:
+            graph.delete_instruction(i)
+            return removed_wires
+    raise KeyError(f"node {node_id} not found")
+
+
+def _node_id_sort_key(value: str) -> tuple[int, int | str]:
+    return (0, int(value)) if value.lstrip("-").isdigit() else (1, value)
+
+
+def connect(
+    graph: AseGraph,
+    src_node: str,
+    src_port: str,
+    dst_node: str,
+    dst_port: str,
+) -> WireLine:
+    """Wire source output port to destination input port (creates data flow src -> dst)."""
+    if graph.node_by_id(src_node) is None:
+        raise KeyError(f"source node {src_node} not found")
+    if graph.node_by_id(dst_node) is None:
+        raise KeyError(f"destination node {dst_node} not found")
+    for w in graph.wires:
+        if (w.in_node, w.in_port, w.out_node, w.out_port) == (dst_node, dst_port, src_node, src_port):
+            return w  # already connected
+        if (w.in_node, w.in_port) == (dst_node, dst_port):
+            raise ValueError(
+                f"destination input {dst_node}:{dst_port} is already connected from "
+                f"{w.out_node}:{w.out_port}"
+            )
+    wire = WireLine(in_node=dst_node, in_port=dst_port, out_node=src_node, out_port=src_port)
+    graph.add_wire(wire)
+    return wire
+
+
+def disconnect(graph: AseGraph, src_node: str, src_port: str, dst_node: str, dst_port: str) -> bool:
+    return graph.remove_wire(
+        out_node=src_node, out_port=src_port, in_node=dst_node, in_port=dst_port
+    )
+
+
+def next_free_node_id(graph: AseGraph) -> int:
+    used = {int(n.node_id) for n in graph.nodes if n.node_id.lstrip("-").isdigit()}
+    candidate = 1
+    while candidate in used:
+        candidate += 1
+    return candidate
+
+
+def node_from_schema(graph: AseGraph, schema: dict, node_id: int | None, pos: str, type_name: str) -> NodeLine:
+    """Build a NodeLine from a runtime schema (schema['fields'] excludes the 6-field prefix)."""
+    if node_id is None:
+        node_id = next_free_node_id(graph)
+    fixed_fields = list(schema.get("fixed_fields", ["Inherit", "False"]))
+    if len(fixed_fields) != 2 or schema.get("fixed_prefix_len", 6) != 6:
+        raise ValueError(f"unsupported fixed node prefix for {type_name}")
+    fields = ["Node", type_name, str(node_id), pos, *fixed_fields]
+    fields.extend(schema["fields"])
+    return NodeLine(type_name=type_name, node_id=str(node_id), raw_fields=fields)
+
+
+def _parse_wire(raw: str) -> WireLine:
+    from .model import _parse_wire_line
+
+    return _parse_wire_line(raw)
+
+
+def _parse_node(raw: str) -> NodeLine:
+    from .model import parse_node_line
+
+    return parse_node_line(raw)

asecli/core/layout.py

@@ -0,0 +1,174 @@
+"""Node layout (FR-0008, ADR-0005): Sugiyama-lite layered arrangement.
+
+Only mutates node position fields (raw_fields[3] = "x,y"). Everything else
+is untouched, and the wire set is preserved by construction.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from .commentary import COMMENTARY_TYPE, inspect_comment_groups
+from .local_vars import local_var_edges
+from .model import AseGraph, NodeLine
+
+MASTER_TYPES = {
+    "AmplifyShaderEditor.TemplateMultiPassMasterNode",
+    "AmplifyShaderEditor.TemplateMasterNode",
+}
+
+
+def layout_positions(
+    graph: AseGraph,
+    gap_x: float = 280.0,
+    gap_y: float = 120.0,
+    origin_x: float = -640.0,
+    origin_y: float = 0.0,
+) -> dict[str, tuple[float, float]]:
+    """Compute tidy left-to-right positions. Deterministic for a given graph."""
+    nodes = graph.nodes
+    frozen = _commentary_composite_nodes(graph)
+    movable_nodes = [node for node in nodes if node.node_id not in frozen]
+    ids = [n.node_id for n in movable_nodes]
+    id_set = set(ids)
+
+    if frozen and movable_nodes:
+        max_right = max(_node_right_edge(node, graph) for node in nodes if node.node_id in frozen)
+        origin_x = max(origin_x, max_right + gap_x)
+
+    # edges: out node feeds in node
+    out_edges: dict[str, list[str]] = defaultdict(list)
+    in_degree: dict[str, int] = {i: 0 for i in ids}
+    edge_pairs = {
+        (w.out_node, w.in_node)
+        for w in graph.wires
+        if w.out_node in id_set and w.in_node in id_set and w.out_node != w.in_node
+    }
+    edge_pairs.update(
+        (source, target)
+        for source, target in local_var_edges(graph)
+        if source in id_set and target in id_set and source != target
+    )
+    for source, target in sorted(edge_pairs):
+        out_edges[source].append(target)
+        in_degree[target] += 1
+
+    masters = {n.node_id for n in movable_nodes if n.type_name in MASTER_TYPES}
+    non_master = [i for i in ids if i not in masters]
+
+    # Kahn topological order with cycle tolerance
+    layer: dict[str, int] = {}
+    queue = [i for i in non_master if in_degree[i] == 0]
+    for i in queue:
+        layer[i] = 0
+    order = list(queue)
+    while order:
+        cur = order.pop(0)
+        for nxt in out_edges.get(cur, []):
+            if nxt in masters:
+                continue
+            layer[nxt] = max(layer.get(nxt, 0), layer[cur] + 1)
+            in_degree[nxt] -= 1
+            if in_degree[nxt] == 0:
+                order.append(nxt)
+    # cycle survivors: place after their longest known predecessor
+    unassigned = [i for i in non_master if i not in layer]
+    changed = True
+    while changed and unassigned:
+        changed = False
+        for i in list(unassigned):
+            preds = [layer[p] for p, outs in out_edges.items() if i in outs and p in layer]
+            if preds:
+                layer[i] = max(preds) + 1
+                unassigned.remove(i)
+                changed = True
+    for i in unassigned:  # fully isolated from everything known
+        layer[i] = 0
+
+    max_layer = max(layer.values(), default=-1)
+    for m in masters:
+        layer[m] = max_layer + 1 if non_master else 0
+    if masters and non_master:
+        max_layer += 1
+
+    # barycenter ordering within layers (two passes), deterministic
+    by_layer: dict[int, list[str]] = defaultdict(list)
+    for n in movable_nodes:  # instruction order = stable initial order
+        by_layer[layer[n.node_id]].append(n.node_id)
+    preds_of: dict[str, list[str]] = defaultdict(list)
+    for src, outs in out_edges.items():
+        for dst in outs:
+            preds_of[dst].append(src)
+
+    y_of: dict[str, float] = {}
+    for l in sorted(by_layer):
+        for row, nid in enumerate(by_layer[l]):
+            y_of[nid] = float(row)
+    for _ in range(2):
+        for l in sorted(by_layer):
+            initial_row = {nid: i for i, nid in enumerate(by_layer[l])}
+            def key(nid: str) -> tuple[float, int]:
+                ps = [y_of[p] for p in preds_of.get(nid, []) if p in y_of]
+                return (sum(ps) / len(ps) if ps else 0.0, initial_row[nid])
+            by_layer[l].sort(key=key)
+            for row, nid in enumerate(by_layer[l]):
+                y_of[nid] = float(row)
+
+    positions: dict[str, tuple[float, float]] = {}
+    for l in sorted(by_layer):
+        members = by_layer[l]
+        rows = len(members)
+        for row, nid in enumerate(members):
+            x = origin_x + l * gap_x
+            y = origin_y + (row - (rows - 1) / 2.0) * gap_y
+            positions[nid] = (round(x, 1), round(y, 1))
+    for node in nodes:
+        if node.node_id in frozen:
+            positions[node.node_id] = _position(node)
+    return positions
+
+
+def apply_positions(graph: AseGraph, positions: dict[str, tuple[float, float]]) -> int:
+    """Write positions back into node raw_fields. Returns count of nodes moved."""
+    moved = 0
+    for n in graph.nodes:
+        pos = positions.get(n.node_id)
+        if pos is None:
+            continue
+        if _position(n) == pos:
+            continue
+        new_xy = f"{pos[0]},{pos[1]}"
+        if n.raw_fields[3] != new_xy:
+            n.raw_fields[3] = new_xy
+            graph.replace_node(n)
+            moved += 1
+    return moved
+
+
+def tidy(graph: AseGraph, gap_x: float = 280.0, gap_y: float = 120.0) -> int:
+    return apply_positions(graph, layout_positions(graph, gap_x, gap_y))
+
+
+def _commentary_composite_nodes(graph: AseGraph) -> set[str]:
+    """Keep curated Comment frames and every member as fixed composite units."""
+    frozen = set()
+    for group in inspect_comment_groups(graph):
+        frozen.add(group["node_id"])
+        frozen.update(group["members"])
+    return frozen
+
+
+def _position(node: NodeLine) -> tuple[float, float]:
+    try:
+        x, y = node.raw_fields[3].split(",")
+        return float(x), float(y)
+    except (IndexError, ValueError) as exc:
+        raise ValueError(f"node {node.node_id} has invalid x,y position") from exc
+
+
+def _node_right_edge(node: NodeLine, graph: AseGraph) -> float:
+    x, _ = _position(node)
+    if node.type_name == COMMENTARY_TYPE:
+        group = next(item for item in inspect_comment_groups(graph) if item["node_id"] == node.node_id)
+        return x + group["width"]
+    return x + 200.0