@troylar/sightline 1.120.3 → 1.175.0

package/CONTRIBUTING.md

@@ -10,10 +10,15 @@ on Windows use a Bash environment with those commands available.
 
 ```sh
 npm ci
+npx playwright install chromium
 ./build.sh
 ./test/run.sh
 ```
 
+The suite includes five layout checks in a real browser, and it fails if Playwright isn't installed, so a local pass
+means the same as CI's. To skip them on purpose, run `SIGHTLINE_NO_BROWSER=1 ./test/run.sh`; the run still says they
+were skipped.
+
 Edit **src/sightline.template.html**, never generated **dist/** files. Build before testing: harnesses execute
 the built HTML. See AGENTS.md for focused checks, deterministic dates and the exact runner requirements.
 

package/dist/sightline-app.py

@@ -28,7 +28,7 @@ import time
 
 # The Sightline page this copy matches. build.sh stamps it into the copy it publishes beside the page; None means this
 # runs from source, where nothing is stamped and nothing is compared.
-PAGE_VERSION = "1.120.3"
+PAGE_VERSION = "1.175.0"
 CONTEXT_FILE = "sightline-assistant-view.json"
 AMENDMENTS_FILE = "sightline-amendments.json"
 RESULTS_FILE = "sightline-assistant-results.json"
@@ -208,7 +208,7 @@ def check_offline(folder: Path, batch: dict) -> list:
                     bad.append(f"{where}: {k} isn't a valid {'date (YYYY-MM-DD)' if t.startswith('iso') else t.rstrip('?')}.")
             if name.endswith(".add") and "id" in spec and not (isinstance(args.get("id"), str) and args["id"]):
                 bad.append(f"{where}: give the new item an id (like risk-vendor-limits), so reading the file again can't add it twice.")
-            if str(name).startswith("jira."):
+            if str(name).startswith("jira.") and name not in ("jira.hide", "jira.unhide"):      # hiding isn't a placement
                 bad.extend(f"{where}: {x}" for x in check_jira_place(ctx.get("jiraSort") or {}, name, args))
     return bad
 
@@ -223,21 +223,33 @@ def check_jira_place(sort: dict, name: str, args: dict) -> list:
     pile = {up(x.get("key")): x for x in sort.get("issues") or [] if isinstance(x, dict)}
     placed = {up(k): v for k, v in (sort.get("placed") or {}).items() if isinstance(v, dict)}
     epics = {up(x.get("key")) for x in sort.get("epics") or [] if isinstance(x, dict)}
+    epic_on = {up(x.get("key")): (x.get("state"), x.get("on")) for x in sort.get("epics") or [] if isinstance(x, dict)}
     targets = sort.get("targets") or {}
-    lanes = {x.get("id") for x in targets.get("workstreams") or [] if isinstance(x, dict)}
+    lane_of = {}                                       # a workstream's id, or a former id it keeps (was) -> its id now
+    for x in targets.get("workstreams") or []:
+        if isinstance(x, dict) and isinstance(x.get("id"), str):
+            lane_of[x["id"]] = x["id"]
+            for o in x.get("was") if isinstance(x.get("was"), list) else []:
+                lane_of.setdefault(o, x["id"])
+    lanes = set(lane_of)
     bars = {x.get("id"): x for x in targets.get("initiatives") or [] if isinstance(x, dict)}
     bad = []
     if name in ("jira.epicLink", "jira.epicNew"):
         epic = up(args.get("epic"))
         if epic not in epics:
             bad.append(f"{epic[:40] or 'epic'} isn't an epic in jiraSort.epics.")
+        state, on = epic_on.get(epic, (None, None))
+        lane_on = next((x.get("lane") for x in targets.get("initiatives") or [] if isinstance(x, dict) and x.get("id") == on), None)
+        here = state == "on" and (on == args.get("id") if name == "jira.epicLink" else lane_on is not None and lane_on == args.get("lane") and args.get("id") in (None, "", on))   # already there: done, as the page says
+        if on and not here and (name == "jira.epicNew" or state == "on"):   # one initiative per epic; a parked one moves on a link
+            bad.append(f"{epic[:40]} is already on {str(on)[:40]} (jiraSort.epics), so it wouldn't be moved.")
     else:
         keys = list(dict.fromkeys(up(k) for k in args.get("keys"))) if isinstance(args.get("keys"), list) else []
         if not keys:
             bad.append("list at least one Jira key in keys.")
         if len(keys) > JIRA_KEYS_MAX:
             bad.append(f"one change places up to {JIRA_KEYS_MAX} issues.")
-        dest = ("notOurs", None) if name == "jira.notOurs" else ("lane", args.get("lane")) if name == "jira.toWorkstream" else ("initiative", args.get("id"))
+        dest = ("notOurs", None) if name == "jira.notOurs" else ("lane", lane_of.get(args.get("lane"), args.get("lane"))) if name == "jira.toWorkstream" else ("initiative", args.get("id"))
         for k in keys:
             if k in pile:
                 continue

package/dist/sightline-jira-sync.py

@@ -71,7 +71,7 @@ BATCH = 50                                                     # keys per JQL qu
 MAX_PLAN_BYTES = 5 * 1024 * 1024
 # The Sightline page this copy matches. build.sh stamps it into the copy it publishes beside the page; None means this
 # runs from source, where nothing is stamped and nothing is compared.
-PAGE_VERSION = "1.120.3"
+PAGE_VERSION = "1.175.0"
 CONTEXT_FILE = "sightline-assistant-view.json"
 PLAN_SCHEMA = 2        # the plan format this script reads; must equal SCHEMA in the page (a test checks)
 STATUS_FORMAT = 1      # the formats this script writes; the page refuses files newer than it knows (a test checks)
@@ -1809,21 +1809,25 @@ ACTIONS = {
     "initiative.setScope": ({"id": "id", "scope": "str"}, True),
     "initiative.delivers.add": ({"id": "id", "outcome": "id"}, False),
     "initiative.delivers.remove": ({"id": "id", "outcome": "id"}, False),
-    "task.add": ({"id": "id?", "bar": "id", "start": "iso", "days": "int?", "label": "str?", "owners": "ids?", "tags": "ids?", "story": "str?"}, False),
+    "task.add": ({"id": "id?", "bar": "id", "start": "iso?", "after": "ids?", "days": "int?", "rough": "bool?", "label": "str?", "owners": "ids?", "tags": "ids?", "story": "str?"}, False),
     "task.set": ({"id": "id", "field": "str", "value": "any"}, True),
     "task.setStatus": ({"id": "id", "status": "str"}, True),
-    "task.move": ({"id": "id", "start": "iso?", "days": "int?"}, True),
+    "task.move": ({"id": "id", "start": "isoOrAfter?", "days": "int?"}, True),
     "task.moveTo": ({"id": "id", "bar": "id"}, True),
     "task.link": ({"id": "id", "after": "id"}, False),
     "task.unlink": ({"id": "id", "after": "id"}, False),
     "task.del": ({"id": "id"}, False),
-    "outcome.add": ({"id": "id?", "name": "str", "source": "str?", "target": "str?", "release": "id?", "date": "iso?", "jira": "keys?"}, False),
+    "outcome.add": ({"id": "id?", "name": "str", "source": "str?", "target": "str?", "release": "id?", "date": "iso?", "jira": "keys?", "capture": "str?", "askedBy": "who?", "raised": "iso?", "lane": "id?"}, False),
     "outcome.set": ({"id": "id", "field": "str", "value": "any"}, True),
     "outcome.setTarget": ({"id": "id", "target": "str?", "date": "iso?"}, True),
     "outcome.setRelease": ({"id": "id", "release": "idOrBlank"}, True),
     "outcome.linkJira": ({"id": "id", "keys": "keys"}, False),
     "outcome.unlinkJira": ({"id": "id", "key": "str"}, False),
     "outcome.drop": ({"id": "id", "reason": "str?"}, False),
+    "outcome.handoff": ({"id": "id", "initiative": "id?", "jira": "str?"}, True),
+    "outcome.reopen": ({"id": "id"}, False),
+    "outcome.raiseAgain": ({"id": "id", "ask": "id", "who": "who?", "raised": "iso?", "source": "str?"}, False),
+    "outcome.unraise": ({"id": "id", "ask": "id"}, False),
     "outcome.del": ({"id": "id"}, True),
     "link.add": ({"id": "id", "after": "id"}, False),
     "link.remove": ({"id": "id", "after": "id"}, False),
@@ -1836,6 +1840,7 @@ ACTIONS = {
     "workstream.setReserve": ({"id": "id", "reserve": "any"}, True),
     "workstream.set": ({"id": "id", "field": "str", "value": "str"}, True),
     "workstream.move": ({"id": "id", "index": "int"}, True),
+    "workstream.reid": ({"lane": "id", "id": "id"}, True),
     "workstream.del": ({"id": "id"}, False),
     "guide.set": ({"section": "str", "value": "str"}, True),
     "guide.setWorkstream": ({"lane": "id", "value": "str"}, True),
@@ -1845,6 +1850,7 @@ ACTIONS = {
     "skill.remove": ({"id": "id"}, False),
     "meeting.set": ({"id": "id", "field": "str", "value": "str"}, True),
     "person.add": ({"id": "id?", "name": "str", "role": "str?", "days": "int?", "outside": "any?"}, False),
+    "group.add": ({"id": "id?", "name": "str", "members": "ids?"}, False),
     "person.set": ({"id": "id", "field": "str", "value": "any"}, True),
     "person.setAlloc": ({"id": "id", "alloc": "any"}, True),
     "person.setSplit": ({"id": "id", "lanes": "weights"}, True),
@@ -1872,6 +1878,9 @@ ACTIONS = {
     "jira.notOurs": ({"keys": "keys"}, False),
     "jira.epicLink": ({"epic": "str", "id": "id"}, False),
     "jira.epicNew": ({"epic": "str", "lane": "id", "id": "id?"}, False),
+    "jira.hide": ({"keys": "keys", "why": "str?"}, False),
+    "jira.unhide": ({"keys": "keys"}, False),
+    "cards.set": ({"field": "str", "value": "any"}, True),
     "risk.add": ({"id": "id?", "text": "str", "sev": "any?", "state": "any?", "owners": "any?", "item": "any?", "next": "any?", "waitingOn": "any?", "escalateBy": "any?", "aiHint": "any?"}, False),
     "risk.set": ({"id": "id", "field": "str", "value": "any"}, True),
     "risk.del": ({"id": "id"}, False),
@@ -1892,6 +1901,8 @@ def _act_type_ok(t: str, v) -> bool:
         return isinstance(v, str) and bool(ACT_ID.match(v))
     if t == "isoOrNull":
         return v is None or _act_type_ok("iso", v)
+    if t == "isoOrAfter":
+        return v == "after" or _act_type_ok("iso", v)
     if t == "idOrBlank":
         return v == "" or _act_type_ok("id", v)
     if t == "ids":
@@ -1902,17 +1913,41 @@ def _act_type_ok(t: str, v) -> bool:
         return isinstance(v, (int, float)) and not isinstance(v, bool) and v == v and abs(v) != float("inf")
     if t == "int":
         return isinstance(v, int) and not isinstance(v, bool)
+    if t == "bool":
+        return isinstance(v, bool)
     if t == "iso":
-        return _valid_iso(v)
+        return _valid_iso(v) or _rel_day(v)
     if t == "keys":
         return isinstance(v, list) and len(v) <= 500 and all(isinstance(k, str) and len(k) <= 40 for k in v)
     if t == "any":
-        return v is None or isinstance(v, bool) or _act_type_ok("num", v) or _act_type_ok("str", v) or _act_type_ok("ids", v)
+        return v is None or isinstance(v, bool) or _act_type_ok("num", v) or _act_type_ok("str", v) or _act_type_ok("ids", v) or _act_type_ok("who", v)
+    if t == "who":      # who asked for a captured item: {"type": "person" or "group", "id": ...}
+        return v is None or (isinstance(v, dict) and set(v) == {"type", "id"} and v["type"] in ("person", "group") and isinstance(v["id"], str) and bool(re.match(r"^[A-Za-z0-9._-]{1,60}$", v["id"])))
     if t == "weights":
         return v is None or (isinstance(v, dict) and len(v) <= 20 and all(_act_type_ok("id", k) and _act_type_ok("int", x) for k, x in v.items()))
     return False
 
 
+_REL_DAY = re.compile(r"^(today|tomorrow|yesterday|(\+ ?|in )\d{1,3} ?(d|days?|w|wks?|weeks?)|- ?\d{1,3} ?(d|days?|w|wks?|weeks?)|\d{1,3} (days?|weeks?) ago"
+                      r"|((this|next|last) )?(mon|tue|wed|thu|fri|sat|sun)[a-z]{0,6}|(next|last) (week|month)|(this|next) sprint)$")
+_REL_WEEKDAYS = ("monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday")
+
+
+def _rel_day(v) -> bool:
+    """A day said in words (next Monday, +3d, 2 weeks ago...): the page reads it against today when it checks the change."""
+    if not isinstance(v, str) or len(v) > 40:
+        return False
+    t = " ".join(v.strip().lower().split())
+    if not _REL_DAY.match(t):
+        return False
+    m = re.match(r"^((this|next|last) )?([a-z]+)$", t)    # a weekday: the start of its name, at least three letters
+    if m and m.group(3) == "month":
+        return m.group(2) in ("next", "last")
+    if m and m.group(3) not in ("today", "tomorrow", "yesterday", "week", "sprint"):
+        return any(d.startswith(m.group(3)) for d in _REL_WEEKDAYS)
+    return True
+
+
 def _valid_iso(v) -> bool:
     if not isinstance(v, str) or not re.match(r"^\d{4}-\d{2}-\d{2}$", v):
         return False
@@ -1950,15 +1985,23 @@ def check_action_op(o, at: str, ids: dict, made: dict) -> str:
         made.setdefault("bar", set()).add(args["id"])
     if creates and "id" in spec and not (isinstance(args.get("id"), str) and args["id"]):
         return f"{at}: give the new item an id (like risk-vendor-limits), so reading the file again can't add it twice"
+    if name == "task.add" and "start" not in args and "after" not in args:
+        return f"{at}: task.add needs a start, or after: the tasks it starts after."
+    if name == "task.add" and isinstance(args.get("after"), list) and args.get("id") and args["id"] in args["after"]:
+        return f"{at}: a task can't start after itself."
+    if name == "task.add" and args.get("after") == []:
+        return f"{at}: after lists the tasks it starts after; leave it out to give only a start."
     for k, v in args.items():
         kind = ACT_REF_BY_NOUN.get(noun) if k == "id" else ACT_REF_BY_ARG.get(k)
         if name == "task.link" or name == "task.unlink":
             kind = "task" if k in ("id", "after") else kind
+        if name == "task.add" and k == "after":
+            kind = "task"
         if name in ("task.add", "task.moveTo") and k == "bar":
             kind = "bar"
         if name == "initiative.waitFor" and k == "gate":
             kind = "gate|block"
-        if not kind or (k == "id" and (creates or name == "jira.epicNew")) or name.endswith(".remove") and k != "id" or name in ("link.remove", "initiative.unwait", "task.unlink", "milestone.doneWhen.remove", "workstream.removeMember", "outcome.unlinkJira") and k != "id":
+        if not kind or (k == "id" and (creates or name in ("jira.epicNew", "workstream.reid"))) or name.endswith(".remove") and k != "id" or name in ("link.remove", "initiative.unwait", "task.unlink", "milestone.doneWhen.remove", "workstream.removeMember", "outcome.unlinkJira") and k != "id":
             continue
         vals = v if isinstance(v, list) else [v]
         for x in vals:
@@ -1966,6 +2009,16 @@ def check_action_op(o, at: str, ids: dict, made: dict) -> str:
                 continue
             if not any(x in ids.get(kd, set()) or x in made.get(kd, set()) for kd in kind.split("|")):
                 return f"{at}: {x[:60]} isn't in the plan (for {k})"
+    if name == "cards.set":
+        e = _cards_set_problem(args)
+        if e:
+            return f"{at}: {e}"
+    if name == "jira.hide" and isinstance(args.get("why"), str) and len(args["why"].strip()) > HIDE_REASON_MAX:
+        return f"{at}: a reason is up to {HIDE_REASON_MAX} characters."
+    if name == "workstream.reid":
+        e = _reid_problem(ids, args)
+        if e:
+            return f"{at}: {e}"
     if noun == "jira" and isinstance(args.get("keys"), list) and len({str(k).strip().upper() for k in args["keys"]}) > 100:
         return f"{at}: one change places up to 100 issues"
     if creates and isinstance(args.get("id"), str):
@@ -1973,12 +2026,70 @@ def check_action_op(o, at: str, ids: dict, made: dict) -> str:
     return ""
 
 
+# The Cards page's layout, as the page has it (harness144 checks these against the page): the fields a card can show,
+# in the order Settings lists them, and the densities. cards.set changes one part of the team's layout.
+CARD_LAYOUT_FIELDS = ["key", "summary", "status", "assignee", "points", "sprint", "epic", "parent", "labels", "priority", "due", "blocked", "initiative"]
+CARD_DENSITY = ["compact", "normal", "detailed"]
+HIDE_REASON_MAX = 200
+
+
+def _cards_set_problem(args) -> str:
+    f, v = args.get("field"), args.get("value")
+    if f not in ("fields", "density", "width"):
+        return "field is one of fields, density, width."
+    if f == "fields":
+        if not isinstance(v, list) or not v:
+            return "fields is a list of at least one field."
+        bad = next((x for x in v if x not in CARD_LAYOUT_FIELDS), None)
+        if bad is not None:
+            return f"{str(bad)[:30]} isn't a card field. They are {', '.join(CARD_LAYOUT_FIELDS)}."
+    if f == "density" and v not in CARD_DENSITY:
+        return f"density is one of {', '.join(CARD_DENSITY)}."
+    if f == "width" and v not in ("fixed", "points"):
+        return 'width is "fixed" or "points".'
+    return ""
+
+
+# A workstream id the page accepts: one in use, or a former id the plan keeps on its workstream (lane.was), which the page
+# reads as the id now. A new id (workstream.reid) follows the rules for a new workstream's and is never one of these.
+LANE_ID = re.compile(r"^(?!(?:constructor|prototype|toString|valueOf|hasOwnProperty)$)[A-Za-z0-9][A-Za-z0-9_.-]{0,59}$")
+
+
+def _lane_ids(plan) -> set:
+    lanes = [l for l in plan.get("lanes") or [] if isinstance(l, dict)]
+    return {l.get("id") for l in lanes} | {x for l in lanes for x in (l.get("was") if isinstance(l.get("was"), list) else []) if isinstance(x, str)}
+
+
+def _lane_of(plan) -> dict:
+    """Each id and former id -> the workstream's id now."""
+    out = {}
+    for l in plan.get("lanes") or []:
+        if isinstance(l, dict) and isinstance(l.get("id"), str):
+            out[l["id"]] = l["id"]
+            for x in l.get("was") if isinstance(l.get("was"), list) else []:
+                if isinstance(x, str):
+                    out.setdefault(x, l["id"])
+    return out
+
+
+def _reid_problem(ids: dict, args: dict) -> str:
+    new, lane_of = args.get("id"), ids.get("laneOf") or {}
+    if not isinstance(new, str) or not LANE_ID.match(new):
+        return "a workstream id is 1 to 60 letters, digits, dots, dashes or underscores, and starts with a letter or digit"
+    if new in lane_of:
+        return "" if lane_of[new] == lane_of.get(args.get("lane")) else f"{new} is, or was, another workstream's id, so it isn't used again"
+    if any(new in ids.get(k, set()) for k in ("bar", "task", "dv", "person", "ms", "gate", "risk", "dec")):
+        return f"{new} is already used"
+    return ""
+
+
 def _plan_ids(plan) -> dict:
     bars = [b for b in plan.get("bars") or [] if isinstance(b, dict)]
     pick = lambda key: {x.get("id") for x in plan.get(key) or [] if isinstance(x, dict)}
     return {"bar": {b.get("id") for b in bars}, "task": {t.get("id") for b in bars for t in b.get("tasks") or [] if isinstance(t, dict)},
-            "dv": pick("deliverables"), "lane": pick("lanes"), "person": pick("people"), "ms": pick("milestones"), "gate": pick("gates"),
-            "block": pick("blocks"), "risk": pick("risks"), "dec": pick("decisions"), "sprint": pick("sprints"), "skill": pick("skills"), "meeting": pick("meetings")}
+            "dv": pick("deliverables"), "lane": _lane_ids(plan), "person": pick("people"), "ms": pick("milestones"), "gate": pick("gates"),
+            "block": pick("blocks"), "risk": pick("risks"), "dec": pick("decisions"), "sprint": pick("sprints"), "skill": pick("skills"), "meeting": pick("meetings"),
+            "laneOf": _lane_of(plan)}
 
 
 def _plan_start(plan) -> _dt.date:
@@ -2009,7 +2120,7 @@ def _item_err(fields, field, v, plan) -> str:
         ids = {p.get("id") for p in plan.get("people") or [] if isinstance(p, dict)}
         return "" if isinstance(v, list) and all(x in ids for x in v) else "owners must be ids of people in the plan"
     if t == "lane":
-        return "" if any(isinstance(l, dict) and l.get("id") == v for l in plan.get("lanes") or []) else f'workstream "{str(v)[:40]}" isn\'t in the plan'
+        return "" if v in _lane_ids(plan) else f'workstream "{str(v)[:40]}" isn\'t in the plan'
     weeks = (plan.get("meta") or {}).get("weeks") or 0
     if t == "start":
         if not _iso_ok(v):
@@ -2063,7 +2174,7 @@ def _value_err(field, v, plan, status) -> str:
     if t == "release":
         return "" if any(str(r.get("id")) == str(v) for r in status.get("releases") or [] if isinstance(r, dict)) else f"release {str(v)[:30]} isn't in the last Jira sync"
     if t == "lane":
-        return "" if any(isinstance(l, dict) and l.get("id") == v for l in plan.get("lanes") or []) else f'workstream "{str(v)[:40]}" isn\'t in the plan'
+        return "" if v in _lane_ids(plan) else f'workstream "{str(v)[:40]}" isn\'t in the plan'
     if t == "people":
         ids = {p.get("id") for p in plan.get("people") or [] if isinstance(p, dict)}
         return "" if isinstance(v, list) and all(x in ids for x in v) else "owners must be ids of people in the plan"