@chrisdudek/yg 5.3.0 → 5.4.1

package/dist/templates/portal/js/views/types-view.js

@@ -0,0 +1,154 @@
+/*
+ * V6 Type Model — the architecture vocabulary as CAPABILITY DISCOVERY.
+ *
+ * "What Yggdrasil can enforce here, and how", seen live on your repo (§3.5/§3a V6). Every node
+ * TYPE the architecture defines, as a card: its description, whether it classifies files or is
+ * organizational, its strict / log flags, its live node-count, what it may nest under (parents),
+ * what it may depend on (the allowed-relations matrix row), and the rules it carries by default.
+ *
+ * This surface renders no verdict state — it is the architecture's grammar, not a pass/fail of
+ * any code — so it deliberately paints no green: the relation hues are relation TYPES, never a
+ * verdict, and a node-count is a fact, not an approval. The honest-state model still owns every
+ * verdict color elsewhere; this view simply never claims one.
+ *
+ * Transitions (§3a V6): a default-rule chip → V5 (that rule in the rulebook); "nodes of this
+ * type" → V3 (the structure tree). Browser globals only; reads the resolved PortalData; no Node.
+ */
+(function () {
+  'use strict';
+
+  var Yg = (window.YgPortal = window.YgPortal || {});
+  var dom = Yg.dom;
+  Yg.views = Yg.views || {};
+
+  // Relation type → a stable, colorblind-safe hue (a relation TYPE marker, never a verdict state).
+  var REL_COLOR = {
+    calls: '#0d74ce',
+    uses: '#208368',
+    extends: '#9a6700',
+    implements: '#8e4ec6',
+    emits: '#d6409f',
+    listens: '#d6409f',
+  };
+
+  /** The "may depend on" line: each allowed relation type with its permitted target types. */
+  function dependsOn(allowed) {
+    var wrap = dom.el('div', 'ty-rels');
+    var any = false;
+    for (var rel in allowed) {
+      if (!Object.prototype.hasOwnProperty.call(allowed, rel)) continue;
+      var targets = (allowed[rel] || []).filter(function (t) {
+        return t !== 'deny' && t !== 'default';
+      });
+      if (!targets.length) continue;
+      any = true;
+      var group = dom.el('span', 'ty-relgroup');
+      var label = dom.el('b', 'ty-reltype');
+      label.style.color = REL_COLOR[rel] || 'var(--text-secondary)';
+      label.textContent = rel;
+      group.appendChild(label);
+      group.appendChild(dom.el('span', 'ty-reltargets', ' ' + targets.join(' · ')));
+      wrap.appendChild(group);
+    }
+    if (!any) wrap.appendChild(dom.el('span', 'ty-rel-none', '— structural parent only (no code dependency permitted)'));
+    return wrap;
+  }
+
+  /** The default-rules line: each rule a clickable chip routing to its detail in V5. */
+  function defaultRules(aspects, nav) {
+    if (!aspects || !aspects.length) return dom.el('span', 'ty-rel-none', '—');
+    var wrap = dom.el('span', 'ty-asps');
+    for (var i = 0; i < aspects.length; i += 1) {
+      var chip = dom.el('button', 'ty-asp mono');
+      chip.type = 'button';
+      chip.textContent = aspects[i];
+      chip.addEventListener(
+        'click',
+        (function (id) {
+          return function () {
+            nav({ view: 'rulebook', aspect: id });
+          };
+        })(aspects[i]),
+      );
+      wrap.appendChild(chip);
+    }
+    return wrap;
+  }
+
+  function typeCard(type, nav) {
+    var card = dom.el('div', 'ty-card');
+
+    var head = dom.el('div', 'ty-head');
+    head.appendChild(dom.el('b', 'mono ty-name', type.id));
+    var classifying = (type.parents && type.parents.length >= 0) && hasRelationsOrAspects(type);
+    head.appendChild(dom.el('span', 'ty-badge ' + (type.nodeCount >= 0 && classifying ? 'ty-badge-cls' : 'ty-badge-org'), classifying ? 'classifying' : 'organizational'));
+    if (type.strict) head.appendChild(dom.el('span', 'ty-badge ty-badge-strict', 'strict'));
+    if (type.logRequired) head.appendChild(dom.el('span', 'ty-badge ty-badge-log', 'log'));
+
+    var count = dom.el('button', 'ty-count');
+    count.type = 'button';
+    count.textContent = type.nodeCount + (type.nodeCount === 1 ? ' node' : ' nodes');
+    count.addEventListener('click', function () {
+      nav({ view: 'tree', type: type.id });
+    });
+    head.appendChild(count);
+    card.appendChild(head);
+
+    if (type.description) card.appendChild(dom.el('div', 'ty-desc', type.description));
+
+    var kv = dom.el('dl', 'ty-kv');
+    kv.appendChild(dom.el('dt', null, 'nests under'));
+    var parents = dom.el('dd', 'mono', (type.parents && type.parents.length) ? type.parents.join(' · ') : '— (top level)');
+    kv.appendChild(parents);
+
+    kv.appendChild(dom.el('dt', null, 'may depend on'));
+    var dd = dom.el('dd');
+    dd.appendChild(dependsOn(type.allowedRelations || {}));
+    kv.appendChild(dd);
+
+    kv.appendChild(dom.el('dt', null, 'default rules'));
+    var ddR = dom.el('dd');
+    ddR.appendChild(defaultRules(type.defaultAspects, nav));
+    kv.appendChild(ddR);
+    card.appendChild(kv);
+
+    return card;
+  }
+
+  /** A type that defines relations or default aspects classifies files; otherwise organizational. */
+  function hasRelationsOrAspects(type) {
+    var rels = type.allowedRelations || {};
+    for (var rel in rels) {
+      if (!Object.prototype.hasOwnProperty.call(rels, rel)) continue;
+      var targets = (rels[rel] || []).filter(function (t) {
+        return t !== 'deny' && t !== 'default';
+      });
+      if (targets.length) return true;
+    }
+    return (type.defaultAspects && type.defaultAspects.length > 0) || type.strict === true;
+  }
+
+  function summary(types) {
+    var strict = 0;
+    var logged = 0;
+    for (var i = 0; i < types.length; i += 1) {
+      if (types[i].strict) strict += 1;
+      if (types[i].logRequired) logged += 1;
+    }
+    return types.length + ' types · ' + strict + ' strict (every matching file must be captured) · ' + logged + ' log-gated (changes must record a reason)';
+  }
+
+  Yg.views.types = function (stage, route, data, ctx) {
+    var nav = ctx && ctx.navigate ? ctx.navigate : function () {};
+    var types = (data.types || []).slice();
+
+    stage.appendChild(dom.el('p', 'view-lead', 'Every kind of component the architecture defines — what it may depend on, and the rules it carries by default. This is what is possible and how, seen live on your repo. It is the grammar, not a verdict: nothing here is green or red.'));
+    stage.appendChild(dom.el('div', 'rb-sub', summary(types)));
+
+    var grid = dom.el('div', 'ty-grid');
+    for (var i = 0; i < types.length; i += 1) {
+      grid.appendChild(typeCard(types[i], nav));
+    }
+    stage.appendChild(grid);
+  };
+})();

package/dist/templates/portal/vendor/d3-hierarchy.js

@@ -0,0 +1,350 @@
+/*
+ * d3-hierarchy (vendored subset) — ISC License, Copyright 2010-2021 Mike Bostock.
+ * https://github.com/d3/d3-hierarchy
+ *
+ * Vendored into the Yggdrasil portal as a committed, offline static asset: no runtime
+ * npm dependency, no CDN, no network. This is the layout MATH only — hierarchy() builds
+ * a node tree from data, and tree() runs the Reingold-Tilford / Buchheim tidy-tree
+ * algorithm to assign (x, y) coordinates. All drawing is the portal's own code; this lib
+ * supplies coordinates and nothing else. It performs no I/O of any kind.
+ *
+ * Exposed as the global `d3` (a minimal namespace with `hierarchy` and `tree`), the same
+ * surface the portal bootstrap consumes, so swapping in the full upstream package later is
+ * a drop-in. Pared to the functions the portal uses; semantics match upstream d3-hierarchy.
+ */
+(function (global) {
+  'use strict';
+
+  // ── hierarchy ────────────────────────────────────────────────────────────────
+  function Node(data) {
+    this.data = data;
+    this.depth = 0;
+    this.height = 0;
+    this.parent = null;
+  }
+
+  Node.prototype = {
+    constructor: Node,
+    each: function (callback) {
+      let index = -1;
+      for (const node of this) callback(node, ++index, this);
+      return this;
+    },
+    eachBefore: function (callback) {
+      const nodes = [this];
+      let node;
+      let index = -1;
+      while ((node = nodes.pop())) {
+        callback(node, ++index, this);
+        const children = node.children;
+        if (children) for (let i = children.length - 1; i >= 0; --i) nodes.push(children[i]);
+      }
+      return this;
+    },
+    descendants: function () {
+      const out = [];
+      this.each((n) => out.push(n));
+      return out;
+    },
+    links: function () {
+      const root = this;
+      const links = [];
+      root.each((node) => {
+        if (node !== root) links.push({ source: node.parent, target: node });
+      });
+      return links;
+    },
+  };
+
+  Node.prototype[Symbol.iterator] = function* () {
+    let node = this;
+    let current = [node];
+    let next = [];
+    do {
+      next = [];
+      for (node of current) {
+        yield node;
+        const children = node.children;
+        if (children) for (const child of children) next.push(child);
+      }
+      current = next;
+    } while (next.length);
+  };
+
+  function computeHeight(node) {
+    let height = 0;
+    do {
+      node.height = height;
+      node = node.parent;
+    } while (node && node.height < ++height);
+  }
+
+  function hierarchy(data, children) {
+    if (data instanceof Map) {
+      data = [undefined, data];
+      if (children === undefined) children = mapChildren;
+    } else if (children === undefined) {
+      children = objectChildren;
+    }
+
+    const root = new Node(data);
+    const nodes = [root];
+    let node;
+    let child;
+    let childs;
+    let i;
+    let n;
+
+    while ((node = nodes.pop())) {
+      if ((childs = children(node.data)) && (n = (childs = Array.from(childs)).length)) {
+        node.children = childs;
+        for (i = n - 1; i >= 0; --i) {
+          nodes.push((child = childs[i] = new Node(childs[i])));
+          child.parent = node;
+          child.depth = node.depth + 1;
+        }
+      }
+    }
+
+    return root.eachBefore(computeHeight);
+  }
+
+  function objectChildren(d) {
+    return d.children;
+  }
+  function mapChildren(d) {
+    return Array.isArray(d) ? d[1] : null;
+  }
+
+  // ── tree (tidy tree — Buchheim/Walker) ─────────────────────────────────────────
+  function defaultSeparation(a, b) {
+    return a.parent === b.parent ? 1 : 2;
+  }
+
+  function nextLeft(v) {
+    const children = v.children;
+    return children ? children[0] : v.t;
+  }
+  function nextRight(v) {
+    const children = v.children;
+    return children ? children[children.length - 1] : v.t;
+  }
+  function moveSubtree(wm, wp, shift) {
+    const change = shift / (wp.i - wm.i);
+    wp.c -= change;
+    wp.s += shift;
+    wm.c += change;
+    wp.z += shift;
+    wp.m += shift;
+  }
+  function executeShifts(v) {
+    let shift = 0;
+    let change = 0;
+    const children = v.children;
+    let i = children.length;
+    let w;
+    while (--i >= 0) {
+      w = children[i];
+      w.z += shift;
+      w.m += shift;
+      shift += w.s + (change += w.c);
+    }
+  }
+  function nextAncestor(vim, v, ancestor) {
+    return vim.a.parent === v.parent ? vim.a : ancestor;
+  }
+
+  function TreeNode(node, i) {
+    this._ = node;
+    this.parent = null;
+    this.children = null;
+    this.A = null; // default ancestor
+    this.a = this; // ancestor
+    this.z = 0; // prelim
+    this.m = 0; // mod
+    this.c = 0; // change
+    this.s = 0; // shift
+    this.t = null; // thread
+    this.i = i; // number
+  }
+  TreeNode.prototype = Object.create(Node.prototype);
+
+  function treeRoot(root) {
+    const tree = new TreeNode(root, 0);
+    let node;
+    const nodes = [tree];
+    let child;
+    let children;
+    let i;
+    let n;
+
+    while ((node = nodes.pop())) {
+      if ((children = node._.children)) {
+        node.children = new Array((n = children.length));
+        for (i = n - 1; i >= 0; --i) {
+          nodes.push((child = node.children[i] = new TreeNode(children[i], i)));
+          child.parent = node;
+        }
+      }
+    }
+
+    (tree.parent = new TreeNode(null, 0)).children = [tree];
+    return tree;
+  }
+
+  function tree() {
+    let separation = defaultSeparation;
+    let dx = 1;
+    let dy = 1;
+    let nodeSize = null;
+
+    function layout(root) {
+      const t = treeRoot(root);
+
+      t.eachAfter(firstWalk);
+      t.parent.m = -t.z;
+      t.eachBefore(secondWalk);
+
+      if (nodeSize) root.eachBefore(sizeNode);
+      else {
+        let left = root;
+        let right = root;
+        let bottom = root;
+        root.eachBefore((node) => {
+          if (node.x < left.x) left = node;
+          if (node.x > right.x) right = node;
+          if (node.depth > bottom.depth) bottom = node;
+        });
+        const s = left === right ? 1 : separation(left, right) / 2;
+        const tx = s - left.x;
+        const kx = dx / (right.x + s + tx);
+        const ky = dy / (bottom.depth || 1);
+        root.eachBefore((node) => {
+          node.x = (node.x + tx) * kx;
+          node.y = node.depth * ky;
+        });
+      }
+
+      return root;
+    }
+
+    function firstWalk(v) {
+      const children = v.children;
+      const siblings = v.parent.children;
+      const w = v.i ? siblings[v.i - 1] : null;
+      if (children) {
+        executeShifts(v);
+        const midpoint = (children[0].z + children[children.length - 1].z) / 2;
+        if (w) {
+          v.z = w.z + separation(v._, w._);
+          v.m = v.z - midpoint;
+        } else {
+          v.z = midpoint;
+        }
+      } else if (w) {
+        v.z = w.z + separation(v._, w._);
+      }
+      v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
+    }
+
+    function secondWalk(v) {
+      v._.x = v.z + v.parent.m;
+      v.m += v.parent.m;
+    }
+
+    function apportion(v, w, ancestor) {
+      if (w) {
+        let vip = v;
+        let vop = v;
+        let vim = w;
+        let vom = vip.parent.children[0];
+        let sip = vip.m;
+        let sop = vop.m;
+        let sim = vim.m;
+        let som = vom.m;
+        let shift;
+        while (((vim = nextRight(vim)), (vip = nextLeft(vip)), vim && vip)) {
+          vom = nextLeft(vom);
+          vop = nextRight(vop);
+          vop.a = v;
+          shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+          if (shift > 0) {
+            moveSubtree(nextAncestor(vim, v, ancestor), v, shift);
+            sip += shift;
+            sop += shift;
+          }
+          sim += vim.m;
+          sip += vip.m;
+          som += vom.m;
+          sop += vop.m;
+        }
+        if (vim && !nextRight(vop)) {
+          vop.t = vim;
+          vop.m += sim - sop;
+        }
+        if (vip && !nextLeft(vom)) {
+          vom.t = vip;
+          vom.m += sip - som;
+          ancestor = v;
+        }
+      }
+      return ancestor;
+    }
+
+    function sizeNode(node) {
+      node.x *= dx;
+      node.y = node.depth * dy;
+    }
+
+    layout.separation = function (x) {
+      if (arguments.length) {
+        separation = x;
+        return layout;
+      }
+      return separation;
+    };
+    layout.size = function (x) {
+      if (arguments.length) {
+        nodeSize = false;
+        dx = +x[0];
+        dy = +x[1];
+        return layout;
+      }
+      return nodeSize ? null : [dx, dy];
+    };
+    layout.nodeSize = function (x) {
+      if (arguments.length) {
+        nodeSize = true;
+        dx = +x[0];
+        dy = +x[1];
+        return layout;
+      }
+      return nodeSize ? [dx, dy] : null;
+    };
+
+    return layout;
+  }
+
+  // eachAfter is needed by the tree layout; add it to the prototype.
+  Node.prototype.eachAfter = function (callback) {
+    const nodes = [this];
+    const next = [];
+    let node;
+    let index = -1;
+    while ((node = nodes.pop())) {
+      next.push(node);
+      const children = node.children;
+      if (children) for (let i = 0, n = children.length; i < n; ++i) nodes.push(children[i]);
+    }
+    while ((node = next.pop())) callback(node, ++index, this);
+    return this;
+  };
+
+  const d3 = { hierarchy: hierarchy, tree: tree };
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = d3;
+  } else {
+    global.d3 = Object.assign(global.d3 || {}, d3);
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisdudek/yg",
-  "version": "5.3.0",
+  "version": "5.4.1",
   "description": "Architecture rules your AI coding agent can't ignore. It gets the rules for a file before it edits, and every change is checked — by a free local script or an LLM reviewer — before it moves on. Works with Claude Code, Cursor, Copilot, Codex, Cline.",
   "type": "module",
   "bin": {
@@ -22,10 +22,12 @@
     "test:watch": "vitest",
     "test:external": "vitest run --config vitest.external.config.ts",
     "test:coverage": "vitest run --coverage",
+    "test:e2e:portal": "playwright test",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
     "format": "prettier --write \"src/**/*.ts\"",
-    "typecheck": "tsc -p tsconfig.check.json"
+    "typecheck": "tsc -p tsconfig.check.json",
+    "typecheck:e2e": "tsc -p tests/portal-e2e/tsconfig.json"
   },
   "keywords": [
     "yggdrasil",
@@ -82,6 +84,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.61.1",
     "@tree-sitter-grammars/tree-sitter-kotlin": "^1.1.0",
     "@tree-sitter-grammars/tree-sitter-toml": "^0.7.0",
     "@tree-sitter-grammars/tree-sitter-yaml": "^0.7.1",