nodecanvas-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nodecanvas-cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Read, search, lint and edit NodeCanvas graphs (Behaviour Trees, FSMs, Dialogue Trees) in Unity projects through the nodecanvas-cli command, without opening Unity.",
   "author": {
     "name": "Aleksandr Esipov"

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.3.0 — 2026-11-06
+
+- `refactor rename-member`: several renames in one run — `Type.Old=New` pairs (`Type.Old(P1,P2)=New` picks an
+  overload) and/or `--file` with one pair per line. One combined diff and lint pass, a per-pair summary,
+  one save; if any pair fails nothing is written. Chains and swaps are rejected. The MCP
+  `refactor_rename_member` tool takes `renames`.
+- `lint --changed`: lint only graphs in files changed since `HEAD` (plus untracked), like
+  `verify --unity --changed`; the MCP `lint` tool takes `changed`. `lint` and `verify` reject `--changed`
+  together with graph names.
+- `lint`: a type saved under a namespace that no longer exists, but found by its short name, is now a
+  `stale-type-name` warning (with "ambiguous" when several types share the name) instead of a
+  `missing-type` / `missing-var-type` error. NodeCanvas resolves such names by short name on load, so
+  `verify --unity` and `lint` used to disagree. `show`/`vars` render these wrappers as `(recovered)`.
+- `lint`: the summary line counts issues hidden by `--min` (`40 info hidden, --min info to show`).
+- `verify --unity`: notes how many Missing wrappers in the file NodeCanvas restored on load.
+- Type names typed by a person (`new --var`, `var-add`, `SetVariable<T>`, `call Type.Member`, `scaffold --agent`,
+  `members`) never resolve by guess. A short name shared by several types is an error listing them, partial
+  qualifiers work (`Arena.Pawn`), a wrong qualifier is no longer ignored, and an unknown short name is an error with
+  suggestions instead of an invented `Name, Assembly-CSharp`. `refactor rename-member Pawn.X=Y` refuses when
+  graphs call two types of that name, where it used to rename both. **Possibly breaking:** types outside the project's
+  sources now need their full name (`UnityEngine.AI.NavMeshAgent`).
+- New type model, following `ParadoxNotion.TypeConverter` and comparing full names. `lint`: new
+  `param-type-mismatch` (task and node parameters against bound variables, with generic types substituted);
+  `mapping-type-mismatch` checks each direction and can now be an error; `arg-type-mismatch` too. Two unrelated
+  components with the same short name or types with no conversion are errors, so `apply`, `copy` and `new` refuse
+  to introduce them without `--force`.
+- `verify --unity` includes static lint errors and type-contract warnings: Unity reports neither, because such
+  types "convert" to null through `GetComponent`.
+- `verify --unity` waits for an Editor that is compiling or reloading scripts instead of failing with "no Editor
+  reachable" right after `unity recompile`, repeats the check if a reload interrupts it, and reports Safe Mode with
+  its compile errors and an open modal dialog as such.
+- Messages, `vars`, `show` and `apply` diffs print full names for types whose short name is not unique.
+- `_objectReferences`: entries nothing uses are removed on every save, so `subgraph-set` no longer leaves the old
+  GUID behind. New `stale-object-ref` lint warning for files that already have such entries. Entries are never
+  touched while a field of unknown type might be using them.
+- `subgraph-set` moves mappings to the new graph's variables of the same name and type and removes the rest,
+  instead of leaving stale ones.
+- Fixed: `extract`, `inline`, `copy --create-vars` and `new --from` copied object values of variables with indices
+  that meant another object, or nothing, in the destination graph.
+- `owners` / `refs`: references to a graph from any field of any asset (`referenced by:
+  Kai_BotData.asset (BotData).fsm`); such graphs are no longer reported as unassigned. Also finds Addressables
+  references and object overrides in `m_Modifications`.
+- `types` explains fields: `[Tooltip]`, `[Name]`, required / blackboard-only marks, also in `--json` (`fields`).
+  The built-in declarations carry short explanations of the main nodes, and `types` lists them in projects
+  without NodeCanvas sources.
+- `apply`: `var-add` takes `after`, `before` or `index`; new `var-move`; `var-set` takes `type`.
+
 ## 0.2.0 — 2026-10-16
 
 - Claude Code plugin: `bin/nodecanvas-cli` puts the command on the agent's PATH (Claude Code 2.1.91+),

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nodecanvas-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Read, query, lint and edit NodeCanvas graphs (Behaviour Trees, FSMs, Dialogue Trees) in Unity projects from the command line
 Project-URL: Homepage, https://github.com/Primeer/nodecanvas-cli
 Project-URL: Issues, https://github.com/Primeer/nodecanvas-cli/issues
@@ -80,7 +80,8 @@ vars: Self:Bot(pub)  Target:Unit  Alert:bool  Cool time:float  Speed:float
   transitions in, dialogue choices), the same for every call of a member or write of a variable, and
   graph statistics.
 - **owners / blackboards** — which prefabs and scenes run a graph (GraphOwner components, exposed
-  variable overrides, owner blackboards), graphs assigned nowhere, and Blackboard / GlobalBlackboard /
+  variable overrides, owner blackboards), which other assets point at it (a field of a ScriptableObject, say),
+  graphs nothing refers to, and Blackboard / GlobalBlackboard /
   AssetBlackboard contents; lint checks global variables and owner overrides against them.
 - **types / members** — discover task and node types with their fields, defaults and enum members, and the
   properties/methods reflection tasks can call.
@@ -154,12 +155,13 @@ nodecanvas-cli why <graph> <node> [--expand]       # conditions on the way from
 nodecanvas-cli paths [graph] --to <Type.Member | $Var> [--reads]
 nodecanvas-cli stats [graph] [--json]
 nodecanvas-cli scaffold action|condition|decorator|composite <Name> --dir Assets/... [--field "x:BBParameter<float>=1"]
-nodecanvas-cli owners [<graph> | --all]            # GraphOwners in prefabs/scenes, parent graphs
+nodecanvas-cli owners [<graph> | --all]            # GraphOwners in prefabs/scenes, parent graphs, other assets
 nodecanvas-cli blackboards [--global]
-nodecanvas-cli lint [graph...] [--min info|warning|error] [--json]
+nodecanvas-cli lint [graph... | --changed] [--min info|warning|error] [--json]
 nodecanvas-cli types [query] [--role action|condition|bt|composite|decorator|fsm|dt]
 nodecanvas-cli members <Type> [filter]
 nodecanvas-cli refactor rename-member|rename-type|retarget ... [--dry-run]
+nodecanvas-cli refactor rename-member Type.Old=New [Type.Old(P1,P2)=New ...] [--file pairs.txt]
 nodecanvas-cli new <path.asset> --kind bt|fsm|dt [--var "Name:type[=value][:pub]"]
 nodecanvas-cli extract <graph> <node> <new.asset> | inline <graph> <node> | copy <src> <node> <dst> <parent>
 nodecanvas-cli apply <graph> <ops.json | -> [--dry-run] [--force]

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/README.md

@@ -49,7 +49,8 @@ vars: Self:Bot(pub)  Target:Unit  Alert:bool  Cool time:float  Speed:float
   transitions in, dialogue choices), the same for every call of a member or write of a variable, and
   graph statistics.
 - **owners / blackboards** — which prefabs and scenes run a graph (GraphOwner components, exposed
-  variable overrides, owner blackboards), graphs assigned nowhere, and Blackboard / GlobalBlackboard /
+  variable overrides, owner blackboards), which other assets point at it (a field of a ScriptableObject, say),
+  graphs nothing refers to, and Blackboard / GlobalBlackboard /
   AssetBlackboard contents; lint checks global variables and owner overrides against them.
 - **types / members** — discover task and node types with their fields, defaults and enum members, and the
   properties/methods reflection tasks can call.
@@ -123,12 +124,13 @@ nodecanvas-cli why <graph> <node> [--expand]       # conditions on the way from
 nodecanvas-cli paths [graph] --to <Type.Member | $Var> [--reads]
 nodecanvas-cli stats [graph] [--json]
 nodecanvas-cli scaffold action|condition|decorator|composite <Name> --dir Assets/... [--field "x:BBParameter<float>=1"]
-nodecanvas-cli owners [<graph> | --all]            # GraphOwners in prefabs/scenes, parent graphs
+nodecanvas-cli owners [<graph> | --all]            # GraphOwners in prefabs/scenes, parent graphs, other assets
 nodecanvas-cli blackboards [--global]
-nodecanvas-cli lint [graph...] [--min info|warning|error] [--json]
+nodecanvas-cli lint [graph... | --changed] [--min info|warning|error] [--json]
 nodecanvas-cli types [query] [--role action|condition|bt|composite|decorator|fsm|dt]
 nodecanvas-cli members <Type> [filter]
 nodecanvas-cli refactor rename-member|rename-type|retarget ... [--dry-run]
+nodecanvas-cli refactor rename-member Type.Old=New [Type.Old(P1,P2)=New ...] [--file pairs.txt]
 nodecanvas-cli new <path.asset> --kind bt|fsm|dt [--var "Name:type[=value][:pub]"]
 nodecanvas-cli extract <graph> <node> <new.asset> | inline <graph> <node> | copy <src> <node> <dst> <parent>
 nodecanvas-cli apply <graph> <ops.json | -> [--dry-run] [--force]

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nodecanvas-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Read, query, lint and edit NodeCanvas graphs (Behaviour Trees, FSMs, Dialogue Trees) in Unity projects from the command line"
 readme = "README.md"
 license = "MIT"

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/skills/nodecanvas-cli/SKILL.md

@@ -89,8 +89,10 @@ their defaults are shown with their real meaning (taken from the project's C# so
 - `nodecanvas-cli owners <graph>` — prefabs/scenes whose GraphOwner (BehaviourTreeOwner, FSMOwner, project
   subclasses) runs the graph, with the owner's Blackboard (and its parent AssetBlackboard) and the
   exposed-variable overrides (`$Var = value`); also parent graphs using it as a subgraph, and PrefabInstances
-  overriding `_graph` (listed, not parsed further). `owners --all` — table of every graph; graphs
-  assigned nowhere in assets are flagged (they may still be assigned from code).
+  overriding `_graph` (listed, not parsed further), and any other asset whose field points at the graph
+  (`referenced by: …Kai_BotData.asset (BotData).fsm`: a ScriptableObject, a component in a prefab or scene, an
+  Addressables reference). `owners --all` — table of every graph; graphs nothing in assets refers to are flagged
+  (they may still be loaded from code). `refs <graph>` lists these references too.
 - `nodecanvas-cli blackboards [--global]` — Blackboard / GlobalBlackboard components and AssetBlackboards
   with their variables.
 - `vars` and `show` mark variables that are not on the graph's own blackboard with their source:
@@ -107,6 +109,10 @@ all commands work on every graph at once, print a compact diff per graph and sup
   tell which one moved (calls of the others are kept and noted), or pick it with `--params Pawn,Vector3`
   (`--params ''` for no parameters); `--all-overloads` renames every overload. When graphs call several
   overloads and nothing tells which one is meant, the command stops with an error.
+  Several members at once — one diff, one save, nothing written if any pair fails:
+  `rename-member Bot.Attack=Strike Bot.speed=moveSpeed "Bot.MoveTo(Unit,Vector3)=Go"` (the `(…)` suffix picks
+  the overload for that pair), or `--file renames.txt` with one `Type.Old=New` per line (`-` for stdin).
+  Chains and swaps (`A=B B=A`) need two runs.
 - `nodecanvas-cli refactor rename-type Old.Namespace.Type New.Namespace.Type [--assembly Asm]` — namespace,
   name or nesting changes (also fixes "missing type" wrappers left by an earlier rename).
 - `nodecanvas-cli refactor retarget BotController.DistanceTo --to Booster [--from Pawn]` — move calls to another
@@ -158,14 +164,31 @@ drops the TODO comments (for projects that do not want comments).
 
 ## Checking graphs
 
-`nodecanvas-cli lint [graph...] [--min info]` reports missing task/variable types, variables that are not on
+`nodecanvas-cli lint [graph... | --changed] [--min info]` (`--changed`: only graphs in files changed since
+`HEAD`, plus untracked ones) reports missing task/variable types, variables that are not on
 the blackboard, reflection bindings to members that no longer exist, unassigned or missing subgraphs,
-stale subgraph variable mappings, arguments whose stored or variable type does not fit the bound
-overload (`arg-type-mismatch`, with a `fix:` op when another overload fits), subgraph mappings between
-variables of different types, too many children for a node type, unreachable nodes, and graph assets whose
+stale subgraph variable mappings, type contracts between variables and what they are bound to (below),
+object references nothing uses (`stale-object-ref`), too many children for a node type, unreachable nodes, and graph assets whose
 `m_Name` differs from the file name (`name-mismatch`, warning — e.g. after renaming the file outside Unity). It exits with 1 when there are errors. Run it
 after C# refactors that touch types used by graphs.
 
+Type contracts: `param-type-mismatch` (a task or node parameter, generic ones included: `SetVariable<A.Pawn>` bound
+to a variable of `B.Pawn`), `mapping-type-mismatch` (a subgraph mapping, in each direction it flows) and
+`arg-type-mismatch` (a reflection argument, with a `fix:` op when another overload fits) follow NodeCanvas's own
+conversions, comparing full type names:
+
+| Case | Severity |
+|---|---|
+| Same type, subclass, `object`, number to a wider number, anything to `string` | none |
+| Through the GameObject: `GameObject` ↔ component, a Unity component ↔ a project one, component → `Vector3` | info |
+| Other conversions (`bool` ↔ `float`, `float` → `int`, `Vector3` → `Vector2`) | warning |
+| Two unrelated project components with different short names: `GetComponent` finds something only if the GameObject has both | warning |
+| Two unrelated project components with the same short name (two `Pawn`s): almost certainly the wrong type | error |
+| No conversion at all | error |
+| A type outside the sources | not reported (info for a mapping) |
+
+Unity reports none of these, since such types do convert (to null): the static checks are what catches them.
+
 Owners and blackboards: `missing-global-var` (warning) — `$Name/Var` has no GlobalBlackboard
 `Name` with that variable; `exposed-override-type` / `exposed-override-stale` (warning) — an owner
 overrides an exposed variable with another type, or one the graph no longer has; `owner-missing-graph`
@@ -185,7 +208,14 @@ editor's minimum node size; `off-grid` (info).
 
 `recoverable-missing` (info) means NodeCanvas once saved a task or variable as "missing" while its type
 did not compile; the type exists again, Unity restores it on load and the wrapper disappears on the
-next save in the editor. `show` renders such tasks with `(recovered)`. It is not an error.
+next save in the editor. `show` renders such tasks with `(recovered)`. It is not an error. Info is
+hidden by default: the summary line says how many (`56 info hidden, --min info to show`).
+
+`stale-type-name` (warning): a saved type name (or a generic argument of it) no longer exists under its
+full name, but a type with the same short name does — usually its namespace changed. NodeCanvas falls
+back to the short name on load, so Unity loads the graph and `verify --unity` reports it as fine;
+`verify --unity --resave` stores the current name. With several types of that name the message says
+"ambiguous": NodeCanvas then takes whichever it meets first.
 
 ## Checking graphs in the Unity Editor
 
@@ -193,7 +223,10 @@ next save in the editor. `show` renders such tasks with `(recovered)`. It is not
 open Unity Editor to re-import each graph, deserialize and validate it, and reports what NodeCanvas sees:
 node/task errors shown red in the graph editor (missing tasks, missing reflected members), Missing
 wrappers left after loading, overloads resolved by name fallback, node/variable counts that differ from
-the file, and console errors logged meanwhile. It waits for script compilation first. Exit code 0 — all
+the file, and console errors logged meanwhile. Every static lint error and type-contract warning for the
+graph is added (`[mapping-type-mismatch] …`), because Unity cannot see those: an error makes the graph `FAIL`, a
+warning prints under `ok`. It waits for script compilation first, and for an Editor that is reloading scripts
+(right after `unity recompile`, say); a project in Safe Mode is reported with its compile errors. Exit code 0 — all
 fine, 1 — problems, 2 — no Editor reachable (it needs the `unity` CLI and the project's
 `com.unity.pipeline` package; `unity pipeline install` adds it). Use it after edits when an Editor is
 open, instead of asking the user to open the graph. Graphs bound in scenes are checked only when the
@@ -205,7 +238,7 @@ wrappers); it changes files, so use it only when asked.
 1. `nodecanvas-cli show <graph>` — note the `#ids` you will touch (ids are positions; they change after every edit).
 2. To learn how to write a node, print a similar existing one with `nodecanvas-cli node <graph> <id>` and
    adapt it. For a task or node type you have not seen yet: `nodecanvas-cli types <Name>` (fields, defaults,
-   enum values) or `nodecanvas-cli types --role action|condition|bt|composite|decorator|fsm|dt`.
+   enum values, and what each field means when the source has a `[Tooltip]`) or `nodecanvas-cli types --role action|condition|bt|composite|decorator|fsm|dt`.
    For reflection tasks: `nodecanvas-cli members <Type> [filter]` lists callable properties/methods.
 3. Write a JSON array of operations and run `nodecanvas-cli apply <graph> ops.json --dry-run` (or `-` for stdin).
    Read the printed before/after diff (blackboard changes follow it as `vars:` lines: `+`/`-` added or removed,
@@ -213,7 +246,8 @@ wrappers); it changes files, so use it only when asked.
    placed, moved by the edit, and which existing subtrees were shifted (and by how much) to make room.
    Add `--positions` to see coordinates in the diff. Then run again without `--dry-run`.
 4. `nodecanvas-cli show <graph>` again to get the new ids before the next batch.
-5. If a Unity Editor is open on the project, `nodecanvas-cli verify --unity --changed` confirms Unity loads the result.
+5. After the last batch, `nodecanvas-cli lint --changed` checks every graph you touched; if a Unity Editor is open
+   on the project, `nodecanvas-cli verify --unity --changed` confirms Unity loads the result.
 
 A batch is atomic: if any operation fails, or the result has new lint errors, nothing is written (use
 `--force` only when the error is expected). Connection limits (e.g. a BinarySelector's two children)

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/skills/nodecanvas-cli/references/ops.md

@@ -102,16 +102,21 @@ syntax as the `map` operation; `nodecanvas-cli node` prints them that way.
 
 | Op | Fields | Notes |
 |---|---|---|
-| `var-add` | `name`, `type`, `value`?, `public`? | `type` is C# (`float`, `bool`, `Vector3`, `Pawn`, `List<Pawn>`). |
-| `var-set` | `name`, `value`?, `public`? | Changes the stored value / exposure. |
+| `var-add` | `name`, `type`, `value`?, `public`?, `after`?/`before`?/`index`? | `type` is C# (`float`, `bool`, `Vector3`, `Pawn`, `List<Pawn>`). Without a position the variable goes last. `after`/`before` name a variable or a section (`"after": "Parameters"`); `index` counts sections too. |
+| `var-set` | `name`, `value`?, `public`?, `type`? | Changes the stored value / exposure / type. `type` keeps the id, so references stay; the old value is converted between primitive types, kept between object types, otherwise dropped (a note says so). Bindings the new type breaks are refused by lint. |
+| `var-move` | `name`, `after`/`before`/`index` | Moves a variable, for example from `Local variables` into `Parameters`. |
 | `var-rename` | `name`, `to` | Updates every reference in this graph. Subgraph mappings in *other* graphs keep working (they use ids). |
 | `var-remove` | `name`, `force`? | Refuses while the variable is used, unless `force`. |
 
+Type names here and in `$type`, `call` and the like must identify one type. A short name shared by several types
+(two `Pawn`s; a project `Transform` and Unity's) is an error listing them: give a full or partial name
+(`Arena.Pawn`). A type outside the project's sources needs its full name (`TMPro.TMP_Text`).
+
 ## Subgraphs
 
 | Op | Fields | Notes |
 |---|---|---|
-| `subgraph-set` | `node`, `graph`, `map`? | Points a SubTree / nested state at another graph asset. |
+| `subgraph-set` | `node`, `graph`, `map`? | Points a SubTree / nested state at another graph asset. Without `map`, existing mappings move to the new graph's variables of the same name and type; the rest are removed, with a note. |
 | `map` | `node`, `map` | Replaces the variable mapping: `{"SubVar": "<-$Parent"}` passes a value in, `"->$Parent"` reads it back after the subgraph runs, `"<->$Parent"` both; a literal passes a constant in. |
 | `map` | `node`, `"auto": true` | Adds mappings for the subgraph's public variables that are not mapped yet, to parent variables with the same name and type; direction from how the subgraph uses each (read → `<-`, written → `->`, both → `<->`). Prints what was mapped and skipped. |
 

nodecanvas_cli-0.3.0/src/nodecanvas_cli/__init__.py

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

nodecanvas_cli-0.3.0/src/nodecanvas_cli/assetrefs.py

@@ -0,0 +1,181 @@
+"""Who references a graph asset from outside the graph system: any field of any ScriptableObject, prefab or scene.
+
+A project may hand graphs out through its own data (``BotData.fsm``), so a graph with no GraphOwner and no parent
+graph is not necessarily dead. Unity keeps such a reference as ``{fileID: 11400000, guid: …, type: 2}`` in the YAML
+of the referencing object (``m_AssetGUID`` for an Addressables reference), so a text scan finds them all.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List
+
+from .container import ObjectRef, _documents, _value_of
+from .project import CONTAINER_SUFFIXES, Cache
+
+_GUID_RE = re.compile(rb"[Gg][Uu][Ii][Dd]: ([0-9a-f]{32})")
+_FILE_ID_RE = re.compile(r"fileID: (-?\d+)")
+# Object lists of graph containers: an entry there is a use only if the graph really uses it.
+GRAPH_REF_LISTS = ("_objectReferences", "_boundGraphObjectReferences")
+_CACHE_KEY = "\0graph guids"  # what the entries were computed for: another set of graphs means another scan
+
+
+@dataclass
+class AssetRef:
+    path: str
+    obj: str  # the referencing object: "Guard (BotBrain)", "(BotData)", "PrefabInstance"
+    field: str  # dotted path of the field
+
+    @property
+    def label(self) -> str:
+        return f"{self.path} {self.obj}.{self.field}" if self.obj else f"{self.path} {self.field}"
+
+
+def yaml_path(lines: List[str], i: int, start: int) -> str:
+    """Dotted field path of line ``i`` inside the document starting at ``start``, from Unity's YAML indentation
+    (list items sit at the indentation of their key)."""
+
+    def split(text: str):
+        item = text.startswith("- ")
+        body = text[2:] if item else text
+        key = body.split(":", 1)[0].strip() if ":" in body and not body.startswith("{") else None
+        return item, key
+
+    text = lines[i].lstrip(" ")
+    col = len(lines[i]) - len(text)
+    in_item, key = split(text)
+    parts = [key] if key else []
+    for j in range(i - 1, start, -1):
+        text = lines[j].lstrip(" ")
+        ind = len(lines[j]) - len(text)
+        if not text or ind == 0:
+            continue
+        item, key = split(text)
+        if in_item:  # the key of this list is at the same indentation
+            if ind <= col and not item and key:
+                parts.append(key)
+                col, in_item = ind, False
+            continue
+        if item and ind + 2 == col:  # a sibling on the list item's own line
+            col, in_item = ind, True
+        elif ind < col and key:
+            parts.append(key)
+            col, in_item = ind, item
+    return ".".join(reversed(parts))
+
+
+def _object_of(ws, lines: List[str], doc, go_names: Dict[str, str]) -> str:
+    start, end, cls, _ = doc
+    if cls == "1001":
+        return "PrefabInstance"
+    script = _value_of(lines, start, end, "m_Script") or ""
+    name = ""
+    if "guid" in script:
+        path = ws.ref_path(ObjectRef.parse(script))
+        name = Path(path).stem if path else ""
+    if not name:
+        name = (_value_of(lines, start, end, "m_EditorClassIdentifier") or "").split("::")[-1].split(".")[-1]
+    m = _FILE_ID_RE.search(_value_of(lines, start, end, "m_GameObject") or "")
+    go = go_names.get(m.group(1), "") if m and m.group(1) != "0" else ""
+    return f"{go} ({name})" if go and name else go or (f"({name})" if name else "")
+
+
+def _scan_file(ws, rel: str, text: str, guids: set) -> List[list]:
+    lines = text.split("\n")
+    docs = _documents(lines)
+    go_names = {fid: _value_of(lines, s, e, "m_Name") or "" for s, e, cls, fid in docs if cls == "1"}
+    out = []
+    for doc in docs:
+        start, end, _, _ = doc
+        for i in range(start, end):
+            m = _GUID_RE.search(lines[i].encode("utf-8", "replace"))
+            if m is None or m.group(1).decode() not in guids:
+                continue
+            guid = m.group(1).decode()
+            field = yaml_path(lines, i, start)
+            if field.endswith("objectReference"):  # a prefab override names its property on the line above
+                prop = _value_of(lines, max(start, i - 2), i, "propertyPath")
+                field = prop or field
+            out.append([guid, _object_of(ws, lines, doc, go_names), field])
+    return out
+
+
+def graph_refs(ws) -> Dict[str, List[AssetRef]]:
+    """``graph guid -> references`` from every ``.asset`` / ``.prefab`` / ``.unity`` (computed once per run)."""
+    cached = getattr(ws, "_asset_refs", None)
+    if cached is not None:
+        return cached
+    paths = {ws.project.path_to_guid(s.path): s.path for s in ws.slots if not s.bound}
+    paths.pop(None, None)
+    guids = set(paths)
+    digest = hashlib.sha1(",".join(sorted(guids)).encode()).hexdigest()[:12]
+    cache = Cache(ws.project.root, "graph-refs")
+    if cache.data.get(_CACHE_KEY) != digest:
+        cache.data = {_CACHE_KEY: digest}
+        cache.dirty = True
+    out: Dict[str, List[AssetRef]] = {}
+    seen = []
+    needles = [g.encode() for g in guids]
+    for f in ws.project.iter_files(CONTAINER_SUFFIXES):
+        rel = ws.project.rel(f)
+        seen.append(rel)
+        st = f.stat()
+        hits = cache.get(rel, st)
+        if hits is None:
+            data = f.read_bytes()
+            hits = []
+            if any(n in data for n in needles):
+                hits = _scan_file(ws, rel, data.decode("utf-8", "replace").replace("\r\n", "\n"), guids)
+            cache.put(rel, st, hits)
+        for guid, obj, field in hits:
+            if paths.get(guid) != rel:  # a graph naming itself is not a use
+                out.setdefault(guid, []).append(AssetRef(rel, obj, field))
+    cache.prune(seen + [_CACHE_KEY])
+    cache.save()
+    ws._asset_refs = out
+    return out
+
+
+def _used_in_graphs(ws, ref: AssetRef, guid: str) -> bool:
+    """An entry in another graph's object list counts only if that graph uses it for something other than a
+    subgraph (which `owners` shows as a parent): a stale entry is no use at all."""
+    from .model import NESTED_KEYS
+    from .typedwalk import object_ref_usage
+
+    for slot in ws.slots:
+        if slot.path != ref.path:
+            continue
+        g = ws.load(slot)
+        if any(
+            isinstance(n.get(k), dict) and (g.ref(n[k].get("_value")) or ObjectRef(0)).guid == guid
+            for n in g.nodes
+            for k in NESTED_KEYS
+        ):
+            continue  # shown as "subgraph of"
+        usage = object_ref_usage(ws, g)
+        used = {h[k] for h, k in usage.slots} | usage.maybe
+        if usage.unsafe or any(r.guid == guid and i in used for i, r in enumerate(g.refs)):
+            return True
+    return False
+
+
+def refs_to(ws, path: str) -> List[AssetRef]:
+    """References to the graph asset at ``path`` that `owners` shows nowhere else."""
+    from .owners import index
+
+    guid = ws.project.path_to_guid(path)
+    idx = index(ws)
+    runs_it = {o.path for o in idx.owners if o.graph is not None and o.graph.guid == guid}
+    runs_it |= {i.path for i in idx.instances if i.graph is not None and i.graph.guid == guid}
+    out = []
+    for ref in graph_refs(ws).get(guid, []):
+        field = ref.field.split(".")[-1]
+        if field == "_graph" and ref.path in runs_it:
+            continue
+        if field in GRAPH_REF_LISTS and not _used_in_graphs(ws, ref, guid):
+            continue
+        out.append(ref)
+    return out

{nodecanvas_cli-0.2.0 → nodecanvas_cli-0.3.0}/src/nodecanvas_cli/assets.py

@@ -15,6 +15,7 @@ from . import fsjson
 from .container import ObjectRef, UnityFile
 from .model import BT, DT, FSM, Graph, walk
 from .schema import generic_args, simple_name
+from .typedwalk import is_write_field, node_ref_slots, prune_refs, variable_ref_slots
 from .views import render_graph
 from .yamlscalar import encode
 
@@ -24,21 +25,6 @@ DERIVED = {
     "fsm": None,
     "dt": {"actorParameters": [], "$type": DT + "+DerivedSerializationData"},
 }
-NESTED_KEYS = ("_subTree", "_nestedBT", "_nestedFSM", "_nestedDLG", "_subGraph")
-WRITE_FIELDS = {
-    "saveAs",
-    "returnValue",
-    "current",
-    "storeIndex",
-    "boolVariable",
-    "floatVariable",
-    "intVariable",
-    "saveIndexAs",
-    "saveDistanceAs",
-    "saveObjectAs",
-    "savePositionAs",
-    "saveTo",
-}
 META = (
     "fileFormatVersion: 2\nguid: {guid}\nNativeFormatImporter:\n  externalObjects: {{}}\n"
     "  mainObjectFileID: 11400000\n  userData: \n  assetBundleName: \n  assetBundleVariant: \n"
@@ -205,7 +191,7 @@ def used_variables(g: Graph, nodes: List[dict]) -> Dict[str, str]:
                 continue
             key = path[-1] if path else ""
             owner_type = _owner_type(n, path)
-            write = key in WRITE_FIELDS or (key == "valueA" and simple_name(owner_type).startswith("Set"))
+            write = is_write_field(key, owner_type)
             if isinstance(key, int) and len(path) >= 2 and path[-2] == "_variablesMap":
                 write = bool(d.get("_canRead"))
             mode = out.get(vid, "")
@@ -223,54 +209,18 @@ def _owner_type(node: dict, path: Tuple) -> str:
 
 
 def object_ref_slots(ws, g: Graph, node: dict) -> List[Tuple[Any, Any]]:
-    """``(container, key)`` of every int in ``node`` that indexes the graph's ``_objectReferences``:
-    fields of a UnityEngine.Object type (also inside BBParameters, lists, nested classes and tasks),
-    found by the field types in the sources."""
-    from .render import _bb_inner, _elem_type
+    """``(container, key)`` of every int in ``node`` that indexes the graph's ``_objectReferences``."""
+    return node_ref_slots(ws, node)
 
-    schema, r = ws.schema, ws.renderer(g)
-    out: Dict[Tuple[int, Any], Tuple[Any, Any]] = {}
 
-    def is_object(t: Optional[str], ctx) -> bool:
-        return bool(t) and "<" not in t and not t.endswith("[]") and r._is_unity_object(t, ctx)
-
-    def visit(v: Any, t: Optional[str], ctx, holder: Any, key: Any) -> None:
-        if isinstance(v, bool) or v is None:
-            return
-        if isinstance(v, int):
-            if is_object(t, ctx):
-                out[(id(holder), key)] = (holder, key)
-            return
-        if isinstance(v, list):
-            et = _elem_type(t)
-            for i, x in enumerate(v):
-                visit(x, et, ctx, v, i)
-            return
-        if not isinstance(v, dict):
-            return
-        if "$content" in v:
-            visit(v["$content"], v.get("$type") or t, ctx, v, "$content")
-            return
-        if "_value" in v and (_bb_inner(t) or "_type" in v or (t or "").startswith("BBObjectParameter")):
-            if not (v.get("_name") or v.get("_targetVariableID")):
-                inner = v.get("_type") or _bb_inner(t)
-                visit(v["_value"], inner.split(",")[0] if inner else None, ctx, v, "_value")
-            return
-        dt = v.get("$type") or t
-        decl = schema.find(dt) if dt else None
-        if decl is None and dt:
-            decl = schema.find_simple(simple_name(dt).split("<")[0], ctx)
-        fields = {n: (f, c) for n, f, c in schema.ordered_fields(decl.full_name)} if decl is not None else {}
-        for k, x in v.items():
-            f = fields.get(k)
-            visit(x, f[0].type if f else None, f[1] if f else ctx, v, k)
-
-    visit(node, None, None, None, None)
-    for k in NESTED_KEYS:  # subgraph references, even when the node type is not in the sources
-        v = node.get(k)
-        if isinstance(v, dict) and isinstance(v.get("_value"), int):
-            out[(id(v), "_value")] = (v, "_value")
-    return list(out.values())
+def copy_variable(ws, src: Graph, dst: Graph, var: dict) -> dict:
+    """A deep copy of a blackboard variable for ``dst``; an object value keeps pointing at the same object."""
+    nv = copy.deepcopy(var)
+    if src is not dst:
+        for holder, key in variable_ref_slots(ws, nv):
+            ref = src.ref(holder[key])
+            holder[key] = dst.ref_index(ref) if ref is not None and not ref.is_null else 0
+    return nv
 
 
 def clone(
@@ -363,6 +313,7 @@ def _finish(ws, a, created: List[Tuple[UnityFile, Graph, str]], changed: List[Gr
         print("dry run: nothing written")
         return 0
     for f, g, guid in created:
+        prune_refs(ws, g)
         f.store(g.loaded)
         f.abspath.parent.mkdir(parents=True, exist_ok=True)
         f.dirty = True
@@ -429,9 +380,10 @@ def cmd_extract(ws, a) -> int:
     var_map: Dict[str, dict] = {}
     for name, v in g.variables.items():
         if v.get("_id") in usage:
-            nv = {k: copy.deepcopy(x) for k, x in v.items() if k not in ("_isPublic", "$type")}
+            nv = copy_variable(ws, g, sub, v)
+            nv.pop("_isPublic", None)
             nv["_isPublic"] = True
-            nv["$type"] = v["$type"]
+            nv["$type"] = nv.pop("$type")
             sub.blackboard["_variables"][name] = nv
             var_map[v["_id"]] = nv
     copies, conns = clone(ws, g, sub, nodes, var_map)
@@ -502,7 +454,8 @@ def cmd_inline(ws, a) -> int:
         new_name = name
         while g.var_by_name(new_name) is not None:
             new_name = f"{new_name} ({sub.name})"
-        nv = {k: copy.deepcopy(x) for k, x in v.items() if k not in ("_isPublic",)}
+        nv = copy_variable(ws, sub, g, v)
+        nv.pop("_isPublic", None)
         nv["_name"] = new_name
         nv["_id"] = v["_id"] if g.var_by_id(v["_id"]) is None else str(uuid.uuid4())
         g.blackboard["_variables"][new_name] = nv
@@ -580,7 +533,7 @@ def copy_subtree(
     if as_root and dst.nodes and dst.kind == "bt":
         raise AssetError(f"{dst.name} already has a root; give a parent node to attach the copy to")
     for v in missing:
-        nv = copy.deepcopy(v)
+        nv = copy_variable(ws, src, dst, v)
         nv.pop("_isPublic", None)
         if public_vars(v["_name"]) if callable(public_vars) else public_vars:
             nv["_isPublic"] = True