@neocompose/cli 0.84.5 → 0.85.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.84.5",
+  "version": "0.85.0",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.84.5 -->
+<!-- reviewed-through-cli: 0.85.0 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -129,7 +129,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.84.5 -->
+<!-- reviewed-through-cli: 0.85.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/neoscript.md

@@ -413,6 +413,33 @@ enum, parameter, or local may shadow it. Qualified members use their owner's
 namespace and may be named `Math`; access one as `this.Math` or
 `SomeValue.Math` without colliding with the builtin qualifier.
 
+## Vector math
+
+`Vector2`, `Vector3`, `Vector2Int`, and `Vector3Int` support `+`, `-`, unary
+`-`, multiplication by a scalar in either order, and division by a scalar.
+Both vector operands must have the same type. Integer vectors accept only
+integer scalars; float vectors accept int or float. Integer division truncates
+toward zero. Division by zero throws. `==` and `!=` keep exact component equality.
+
+```neo
+Vector2 next = position + direction * speed;
+float distance = Vector2.Distance(position, target);
+Vector2 heading = (target - position).normalized;
+Vector2 step = Vector2.MoveTowards(position, target, speed);
+```
+
+All vectors expose read-only `magnitude` and `sqrMagnitude`, static `Distance`,
+`Min`, `Max`, and constants `zero`, `one`, `up`, `down`, `left`, and `right`.
+Three-dimensional vectors also have `forward` and `back`. Float vectors add
+`normalized`, `Dot`, `Lerp`, and `MoveTowards`; `Vector3` adds `Cross`.
+Integer vectors have no implicit conversion to float vectors.
+
+`Color.Lerp(a, b, t)` interpolates all four channels, including alpha.
+Both vector and Color `Lerp` clamp t to [0, 1]. `normalized` returns zero when
+the magnitude is at most 0.00001. A negative MoveTowards delta moves away.
+Computed properties are read-only; arithmetic, math results, and constants
+are fresh values. Component writes retain the ordinary vector aliasing rules.
+
 ## String builtins
 
 Use `text.Replace(search, replacement)` to return a string with every
@@ -424,6 +451,36 @@ may be null. The receiver stays unchanged.
 return "banana".Replace("a", "o"); // "bonono"
 ```
 
+Strings also have `Length`, `Substring(startIndex[, length])`, `IndexOf`,
+`LastIndexOf`, `Split(separator)`, `PadLeft`/`PadRight(totalWidth[,
+paddingChar])`, `Trim`, `TrimStart`, and `TrimEnd`, plus the statics
+`string.Join(separator, values)`, `string.IsNullOrEmpty`, and
+`string.IsNullOrWhiteSpace`. Lengths and indices count UTF-16 code units, every
+comparison is ordinal, and whitespace is C#'s `char.IsWhiteSpace` set. `Split`
+keeps empty entries and returns a new list. `Join` takes a `List<string>` or
+`Set<string>`; turn other entries into text first with
+`values.Select(v => $"{v}")`. `s?.Length` is an error; use
+`string.IsNullOrEmpty(s)` or narrow first.
+
+```neo
+List<string> parts = this.Text.Trim().Split(" ");
+int quantity = int.TryParse(parts[1]) ?? 0;
+return $"{slot.ToString("D3")} {price.ToString("N2")}";
+```
+
+`int.Parse`, `float.Parse`, and `decimal.Parse` accept ASCII digits with an
+optional sign (plus a fraction for `float` and `decimal`, and an exponent for
+`float`) after trimming ASCII whitespace, and throw on anything else or on a
+value the type can't hold. `TryParse` returns `null` instead of throwing.
+`decimal.Parse` never rounds: more than 28 significant or fractional digits is
+an error.
+
+Numbers format only with an explicit format: `D<n>` (int only, zero-padded),
+`F<n>` (fixed point), or `N<n>` (fixed point with `,` grouping), where `n` is 0
+to 28 and defaults to 2 (1 for `D`). `float` rounds half to even from its exact
+value, `decimal` rounds half away from zero, and a result that is all zeros has
+no `-` sign. For plain text, use interpolation: `$"{value}"`.
+
 Integer inputs assigned to `float` round to float32. This also applies to
 function arguments and returns, collection entries, and `List.Repeat` with a
 float entry type. `Contains` and `IndexOf` on float collections also convert
@@ -466,6 +523,44 @@ return this.Beds
   .Take(10);
 ```
 
+`Sum`, `Average`, `Min`, and `Max` accept zero arguments or one selector.
+Sum/Average require int, float, or decimal values; Min/Max also accept strings
+and bools. Null values are skipped. Sum returns zero on empty input; the other
+reductions return null for nullable input and throw for required input.
+Average of ints returns float. Decimal calculations stay exact; decimal Average
+rounds half-even within Neo's 28-digit envelope. Float Min stops at the first
+NaN; Max prefers ordinary values to NaN.
+
+`MinBy((item) => item.Score)` and `MaxBy(...)` return the first entry with the
+winning key. They skip null keys unless every key is null, then keep the first
+entry. Empty input throws unless the entry type is nullable.
+
+List and Set support `Aggregate((acc, item) => ...)`,
+`Aggregate(seed, (acc, item) => ...)`, `Distinct()`, and
+`Zip(other, (left, right) => ...)`. Aggregate visits entries in order; an empty
+unseeded fold throws. Distinct retains first occurrences using Contains equality
+and returns a read-only List, including nullable entries. Zip stops at the
+shorter input.
+
+`GroupBy((item) => item.Category)` returns a read-only dictionary of read-only
+lists. `ToDictionary((item) => item.Name)` optionally accepts a second value
+selector. Keys must be non-null strings or enum values; duplicate dictionary
+keys throw. Dictionary callbacks take `(key, value)`. `.Keys` and `.Values`
+return read-only lists in dictionary traversal order (integer-looking string
+keys precede other strings in numeric order).
+
+Chain `ThenBy` or `ThenByDescending` after OrderBy to add stable secondary keys.
+An inferred `var` retains this capability; ordinary List/Set annotations,
+function boundaries, and non-ordering queries erase it. Every ordering call is
+eager: it caches keys and sorts the snapshot, costing O(n log n * k) for k key
+levels. Each selector runs once per entry per level. Mutating a snapshot through an explicitly writable local alias invalidates its cached keys; ThenBy then throws until a new OrderBy establishes an ordering.
+
+Writable ordered lists support `items.Sort()` for scalar entries or
+`items.Sort((left, right) => left.Score - right.Score)` for an int comparison.
+Sort returns void, preserves entry identity, and is stable. It rejects mutation
+of the target list through aliases while comparisons run; entry fields retain
+their existing write permissions. A failed comparison leaves the order unchanged.
+
 Use `items.IndexOf(value)` to return the zero-based index of the first equal
 list entry, or `-1` when the value is absent. `IndexOf` is list-only and uses
 the same equality as `Contains`.