@nklisch/pi-agile-workflow 0.15.3

package/work-view/crates/cli/tests/board-js/expanded-browsing.test.mjs

@@ -0,0 +1,79 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { TestEvent, installDomGlobals, loadBoardModule, makeItem } from "./harness.mjs";
+
+test("epic filters match an epic and all descendants through parent chains", async () => {
+  installDomGlobals();
+  const { createDefaultFilters, deriveFilterOptions, epicIdForItem, matchesFilters } = await loadBoardModule("filters.js");
+  const items = [
+    makeItem({ id: "epic-alpha", kind: "epic", parent: null }),
+    makeItem({ id: "feature-alpha", kind: "feature", parent: "epic-alpha" }),
+    makeItem({ id: "story-alpha", kind: "story", parent: "feature-alpha" }),
+    makeItem({ id: "epic-beta", kind: "epic", parent: null }),
+    makeItem({ id: "story-beta", kind: "story", parent: "epic-beta" }),
+    makeItem({ id: "cycle-a", kind: "story", parent: "cycle-b" }),
+    makeItem({ id: "cycle-b", kind: "feature", parent: "cycle-a" }),
+  ];
+  const snapshot = { items };
+  const options = deriveFilterOptions(snapshot);
+  assert.deepEqual(options.epics, ["epic-alpha", "epic-beta"]);
+  assert.equal(epicIdForItem(items[2], new Map(items.map((item) => [item.id, item]))), "epic-alpha");
+  assert.equal(epicIdForItem(items[5], new Map(items.map((item) => [item.id, item]))), "");
+
+  const filters = createDefaultFilters();
+  filters.epics = new Set(["epic-alpha"]);
+  assert.equal(matchesFilters(items[0], filters, snapshot), true);
+  assert.equal(matchesFilters(items[1], filters, snapshot), true);
+  assert.equal(matchesFilters(items[2], filters, snapshot), true);
+  assert.equal(matchesFilters(items[3], filters, snapshot), false);
+  assert.equal(matchesFilters(items[4], filters, snapshot), false);
+});
+
+test("tag and epic groups expand in the sidebar without changing filter semantics", async () => {
+  const { document } = installDomGlobals();
+  const { createDefaultFilters, renderFilterBar } = await loadBoardModule("filters.js");
+  const tags = Array.from({ length: 16 }, (_, index) => `tag-${index + 1}`);
+  const items = [
+    makeItem({ id: "epic-alpha", kind: "epic", tags: ["tag-1"] }),
+    ...tags.map((tag, index) => makeItem({
+      id: `story-${index}`,
+      kind: "story",
+      parent: "epic-alpha",
+      tags: [tag],
+    })),
+  ];
+  const filters = createDefaultFilters();
+  let setFilterCalls = 0;
+  const ctx = {
+    getState: () => ({ snapshot: { items }, filters }),
+    setFilter(key, value) {
+      setFilterCalls += 1;
+      filters[key] = value;
+    },
+  };
+  const root = document.createElement("aside");
+  const ui = renderFilterBar(root, ctx);
+  ui.sync(ctx.getState());
+
+  const tagOptions = root.querySelectorAll(".filter-options")
+    .find((node) => node.getAttribute("aria-label") === "Tag filters");
+  const tagToggle = root.querySelectorAll(".filter-expand-toggle")
+    .find((button) => button.dataset.expandKey === "tags");
+  assert.ok(tagOptions);
+  assert.ok(tagToggle);
+  assert.equal(tagToggle.tagName, "BUTTON");
+  assert.notEqual(tagToggle.getAttribute("tabindex"), "-1");
+  assert.equal(tagOptions.dataset.expanded, "false");
+  assert.equal(tagToggle.getAttribute("aria-expanded"), "false");
+
+  tagToggle.dispatchEvent(new TestEvent("keydown", { key: "Enter", cancelable: true }));
+  assert.equal(tagOptions.dataset.expanded, "true");
+  assert.equal(tagToggle.getAttribute("aria-expanded"), "true");
+
+  const tagButton = tagOptions.querySelectorAll(".filter-chip")
+    .find((button) => button.dataset.filterValue === "tag-3");
+  tagButton.dispatchEvent(new TestEvent("click", { cancelable: true }));
+  assert.equal(setFilterCalls, 1);
+  assert.deepEqual(Array.from(filters.tags), ["tag-3"]);
+});

package/work-view/crates/cli/tests/board-js/harness-smoke.test.mjs

@@ -0,0 +1,11 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { installDomGlobals, loadBoardModule } from "./harness.mjs";
+
+test("board asset modules load through the no-build harness", async () => {
+  installDomGlobals();
+  const filters = await loadBoardModule("filters.js");
+  assert.equal(typeof filters.createDefaultFilters, "function");
+  assert.equal(typeof filters.matchesFilters, "function");
+});

package/work-view/crates/cli/tests/board-js/harness.mjs

@@ -0,0 +1,437 @@
+import { mkdtemp, readFile, readdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const assetRoot = resolve(here, "../../src/board/assets");
+let moduleGraphDir = null;
+
+class StyleDeclaration {
+  setProperty(name, value) {
+    this[name] = String(value);
+  }
+}
+
+class ClassList {
+  constructor(element) {
+    this.element = element;
+  }
+
+  values() {
+    return this.element.className.split(/\s+/).filter(Boolean);
+  }
+
+  add(...names) {
+    const values = new Set(this.values());
+    for (const name of names) {
+      if (name) {
+        values.add(String(name));
+      }
+    }
+    this.element.className = Array.from(values).join(" ");
+  }
+
+  remove(...names) {
+    const remove = new Set(names.map(String));
+    this.element.className = this.values().filter((name) => !remove.has(name)).join(" ");
+  }
+
+  toggle(name, force = undefined) {
+    const shouldAdd = force === undefined ? !this.contains(name) : Boolean(force);
+    if (shouldAdd) {
+      this.add(name);
+    } else {
+      this.remove(name);
+    }
+    return shouldAdd;
+  }
+
+  contains(name) {
+    return this.values().includes(String(name));
+  }
+}
+
+class TestNode {
+  constructor(ownerDocument, nodeType, nodeName) {
+    this.ownerDocument = ownerDocument;
+    this.nodeType = nodeType;
+    this.nodeName = nodeName;
+    this.parentNode = null;
+    this.childNodes = [];
+    this.isConnected = false;
+  }
+
+  append(...children) {
+    for (const child of children.flat()) {
+      const node = typeof child === "string"
+        ? this.ownerDocument.createTextNode(child)
+        : child;
+      if (!node) {
+        continue;
+      }
+      if (node.parentNode) {
+        node.remove();
+      }
+      node.parentNode = this;
+      node.isConnected = this.isConnected;
+      this.childNodes.push(node);
+      markConnected(node, node.isConnected);
+    }
+  }
+
+  replaceChildren(...children) {
+    for (const child of this.childNodes) {
+      child.parentNode = null;
+      markConnected(child, false);
+    }
+    this.childNodes = [];
+    this.append(...children);
+  }
+
+  remove() {
+    if (!this.parentNode) {
+      return;
+    }
+    const siblings = this.parentNode.childNodes;
+    const index = siblings.indexOf(this);
+    if (index !== -1) {
+      siblings.splice(index, 1);
+    }
+    this.parentNode = null;
+    markConnected(this, false);
+  }
+
+  hasChildNodes() {
+    return this.childNodes.length > 0;
+  }
+
+  get children() {
+    return this.childNodes.filter((child) => child.nodeType === 1);
+  }
+
+  get textContent() {
+    if (this.nodeType === 3) {
+      return this.data;
+    }
+    return this.childNodes.map((child) => child.textContent).join("");
+  }
+
+  set textContent(value) {
+    if (this.nodeType === 3) {
+      this.data = String(value);
+      return;
+    }
+    this.replaceChildren(this.ownerDocument.createTextNode(String(value)));
+  }
+}
+
+class TestText extends TestNode {
+  constructor(ownerDocument, text) {
+    super(ownerDocument, 3, "#text");
+    this.data = String(text);
+  }
+}
+
+class TestElement extends TestNode {
+  constructor(ownerDocument, tagName) {
+    super(ownerDocument, 1, String(tagName).toUpperCase());
+    this.tagName = String(tagName).toUpperCase();
+    this.attributes = new Map();
+    this.dataset = {};
+    this.style = new StyleDeclaration();
+    this.className = "";
+    this.classList = new ClassList(this);
+    this.eventListeners = new Map();
+    this.disabled = false;
+    this.hidden = false;
+    this.value = "";
+    this.type = "";
+    this.id = "";
+    this.tabIndex = undefined;
+  }
+
+  setAttribute(name, value) {
+    const text = String(value);
+    this.attributes.set(name, text);
+    if (name === "class") {
+      this.className = text;
+    } else if (name === "id") {
+      this.id = text;
+    } else if (name === "tabindex") {
+      this.tabIndex = Number.parseInt(text, 10);
+    } else if (name.startsWith("data-")) {
+      this.dataset[dataKey(name.slice(5))] = text;
+    } else {
+      this[name] = text;
+    }
+  }
+
+  getAttribute(name) {
+    if (name === "class") {
+      return this.className || null;
+    }
+    if (name === "id") {
+      return this.id || null;
+    }
+    if (name === "tabindex" && this.tabIndex !== undefined) {
+      return String(this.tabIndex);
+    }
+    return this.attributes.has(name) ? this.attributes.get(name) : null;
+  }
+
+  removeAttribute(name) {
+    this.attributes.delete(name);
+    if (name === "class") {
+      this.className = "";
+    } else if (name === "id") {
+      this.id = "";
+    } else if (name.startsWith("data-")) {
+      delete this.dataset[dataKey(name.slice(5))];
+    } else {
+      delete this[name];
+    }
+  }
+
+  addEventListener(type, listener) {
+    const listeners = this.eventListeners.get(type) || [];
+    listeners.push(listener);
+    this.eventListeners.set(type, listeners);
+  }
+
+  removeEventListener(type, listener) {
+    const listeners = this.eventListeners.get(type) || [];
+    this.eventListeners.set(type, listeners.filter((entry) => entry !== listener));
+  }
+
+  dispatchEvent(event) {
+    event.target ||= this;
+    event.currentTarget = this;
+    for (const listener of this.eventListeners.get(event.type) || []) {
+      listener.call(this, event);
+      if (event.immediatePropagationStopped) {
+        break;
+      }
+    }
+    if (
+      event.type === "keydown"
+      && this.tagName === "BUTTON"
+      && !event.defaultPrevented
+      && (event.key === "Enter" || event.key === " " || event.key === "Space")
+    ) {
+      const click = new TestEvent("click", { cancelable: true });
+      this.dispatchEvent(click);
+      if (click.defaultPrevented && event.cancelable) {
+        event.preventDefault();
+      }
+    }
+    return !event.defaultPrevented;
+  }
+
+  focus() {
+    this.ownerDocument.activeElement = this;
+  }
+
+  querySelector(selector) {
+    return this.querySelectorAll(selector)[0] || null;
+  }
+
+  querySelectorAll(selector) {
+    const selectors = selector.split(",").map((part) => part.trim()).filter(Boolean);
+    const matches = [];
+    walkElements(this, (element) => {
+      if (element !== this && selectors.some((part) => matchesSelector(element, part))) {
+        matches.push(element);
+      }
+    });
+    return matches;
+  }
+
+  closest(selector) {
+    let current = this;
+    while (current) {
+      if (current.nodeType === 1 && matchesSelector(current, selector)) {
+        return current;
+      }
+      current = current.parentNode;
+    }
+    return null;
+  }
+}
+
+class TestDocument extends TestElement {
+  constructor() {
+    super(null, "#document");
+    this.ownerDocument = this;
+    this.nodeType = 9;
+    this.nodeName = "#document";
+    this.documentElement = new TestElement(this, "html");
+    this.body = new TestElement(this, "body");
+    this.activeElement = this.body;
+    this.isConnected = true;
+    this.documentElement.isConnected = true;
+    this.body.isConnected = true;
+    this.documentElement.append(this.body);
+    this.childNodes = [this.documentElement];
+  }
+
+  createElement(tagName) {
+    return new TestElement(this, tagName);
+  }
+
+  createElementNS(_namespace, tagName) {
+    return new TestElement(this, tagName);
+  }
+
+  createTextNode(text) {
+    return new TestText(this, text);
+  }
+
+  createDocumentFragment() {
+    const fragment = new TestElement(this, "#fragment");
+    fragment.nodeType = 11;
+    fragment.nodeName = "#document-fragment";
+    return fragment;
+  }
+}
+
+export class TestEvent {
+  constructor(type, options = {}) {
+    this.type = type;
+    this.bubbles = Boolean(options.bubbles);
+    this.cancelable = Boolean(options.cancelable);
+    this.defaultPrevented = false;
+    this.immediatePropagationStopped = false;
+    this.key = options.key || "";
+    this.shiftKey = Boolean(options.shiftKey);
+    this.target = options.target || null;
+    this.currentTarget = null;
+  }
+
+  preventDefault() {
+    if (this.cancelable) {
+      this.defaultPrevented = true;
+    }
+  }
+
+  stopImmediatePropagation() {
+    this.immediatePropagationStopped = true;
+  }
+}
+
+export function installDomGlobals({ width = 1024 } = {}) {
+  const document = new TestDocument();
+  const listeners = new Map();
+  const window = {
+    document,
+    innerWidth: width,
+    localStorage: null,
+    addEventListener(type, listener) {
+      const values = listeners.get(type) || [];
+      values.push(listener);
+      listeners.set(type, values);
+    },
+    removeEventListener(type, listener) {
+      const values = listeners.get(type) || [];
+      listeners.set(type, values.filter((entry) => entry !== listener));
+    },
+    dispatchEvent(event) {
+      for (const listener of listeners.get(event.type) || []) {
+        listener.call(window, event);
+      }
+      return !event.defaultPrevented;
+    },
+    setTimeout,
+    clearTimeout,
+  };
+
+  globalThis.window = window;
+  globalThis.document = document;
+  globalThis.Event = TestEvent;
+  globalThis.KeyboardEvent = TestEvent;
+  globalThis.URL = URL;
+  return { document, window };
+}
+
+export async function loadBoardModule(name) {
+  const dir = await ensureModuleGraph();
+  return import(`${pathToFileURL(join(dir, name)).href}?v=${Date.now()}-${Math.random()}`);
+}
+
+export function makeItem(overrides = {}) {
+  return {
+    id: "story-alpha",
+    kind: "story",
+    stage: "implementing",
+    parent: null,
+    tags: [],
+    depends_on: [],
+    unmet_deps: [],
+    dependents: [],
+    children: [],
+    body: "Story body",
+    updated: "2026-06-01",
+    ready: false,
+    blocked: false,
+    is_terminal: false,
+    tier: "active",
+    ...overrides,
+  };
+}
+
+async function ensureModuleGraph() {
+  if (moduleGraphDir) {
+    return moduleGraphDir;
+  }
+  moduleGraphDir = await mkdtemp(join(tmpdir(), "board-js-assets-"));
+  const files = (await readdir(assetRoot)).filter((file) => file.endsWith(".js"));
+  await Promise.all(files.map(async (file) => {
+    const source = await readFile(join(assetRoot, file), "utf8");
+    const rewritten = source.replaceAll(/from\s+["']\/assets\/([^"']+)["']/g, 'from "./$1"');
+    await writeFile(join(moduleGraphDir, file), rewritten, "utf8");
+  }));
+  return moduleGraphDir;
+}
+
+function dataKey(name) {
+  return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+function markConnected(node, connected) {
+  node.isConnected = connected;
+  for (const child of node.childNodes || []) {
+    markConnected(child, connected);
+  }
+}
+
+function walkElements(root, visit) {
+  for (const child of root.childNodes || []) {
+    if (child.nodeType === 1) {
+      visit(child);
+      walkElements(child, visit);
+    }
+  }
+}
+
+function matchesSelector(element, selector) {
+  const attrMatch = selector.match(/^(.+)(\[.+\])$/);
+  if (attrMatch) {
+    return matchesSelector(element, attrMatch[1]) && matchesSelector(element, attrMatch[2]);
+  }
+  const notTabIndex = selector.match(/^(.*):not\(\[tabindex=['"]?-1['"]?\]\)$/);
+  if (notTabIndex) {
+    return matchesSelector(element, notTabIndex[1]) && element.getAttribute("tabindex") !== "-1";
+  }
+  if (selector.startsWith(".")) {
+    return element.classList.contains(selector.slice(1));
+  }
+  if (selector.startsWith("#")) {
+    return element.id === selector.slice(1);
+  }
+  const attr = selector.match(/^\[([^=\]]+)(?:=['"]?([^'"\]]+)['"]?)?\]$/);
+  if (attr) {
+    const value = element.getAttribute(attr[1]);
+    return attr[2] === undefined ? value !== null : value === attr[2];
+  }
+  return element.tagName.toLowerCase() === selector.toLowerCase();
+}

package/work-view/crates/cli/tests/board-js/kanban-detail.test.mjs

@@ -0,0 +1,75 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { TestEvent, installDomGlobals, loadBoardModule, makeItem } from "./harness.mjs";
+
+test("kanban lanes group by parent and lane focus does not mutate global filters", async () => {
+  const { document } = installDomGlobals();
+  const { createDefaultFilters } = await loadBoardModule("filters.js");
+  const { groupItemsByLane, laneProgress, kanbanView } = await loadBoardModule("kanban.js");
+  const items = [
+    makeItem({ id: "epic-alpha", kind: "epic", parent: null, stage: "done", is_terminal: true }),
+    makeItem({ id: "feature-alpha", kind: "feature", parent: "epic-alpha", stage: "review" }),
+    makeItem({ id: "story-alpha", kind: "story", parent: "feature-alpha", stage: "implementing" }),
+    makeItem({ id: "orphan", kind: "story", parent: null, stage: "drafting" }),
+  ];
+
+  const lanes = groupItemsByLane(items);
+  assert.deepEqual(Array.from(lanes.keys()).sort(), ["(no parent)", "epic-alpha", "feature-alpha"]);
+  assert.deepEqual(laneProgress(lanes.get("epic-alpha")), { done: 1, total: 2 });
+
+  const filters = createDefaultFilters();
+  let setFilterCalls = 0;
+  const ctx = {
+    visibleItems: () => items,
+    getState: () => ({ snapshot: { items }, filters }),
+    setFilter: () => { setFilterCalls += 1; },
+    renderCard: (item) => {
+      const node = document.createElement("article");
+      node.dataset.id = item.id;
+      return node;
+    },
+  };
+  const root = document.createElement("main");
+  document.body.append(root);
+  kanbanView.mount(root, ctx);
+
+  const laneButton = root.querySelectorAll(".kanban-lane-chip")
+    .find((button) => button.dataset.lane === "epic-alpha");
+  assert.ok(laneButton);
+  laneButton.dispatchEvent(new TestEvent("click", { cancelable: true }));
+
+  assert.equal(setFilterCalls, 0);
+  assert.deepEqual(Array.from(filters.parents), []);
+  assert.deepEqual(Array.from(filters.tags), []);
+});
+
+test("detail presentation and selected id refresh behavior are deterministic", async () => {
+  installDomGlobals();
+  const { detectDetailPresentation } = await loadBoardModule("detail.js");
+  const { createBoardStore } = await loadBoardModule("state.js");
+
+  assert.equal(detectDetailPresentation(makeItem({ body: "short" }), 500), "modal");
+  assert.equal(detectDetailPresentation(makeItem({ body: "short" }), 1024), "drawer-narrow");
+  assert.equal(detectDetailPresentation(makeItem({ body: "x".repeat(1200) }), 1024), "drawer-wide");
+  assert.equal(detectDetailPresentation(makeItem({ body: "x".repeat(2600) }), 1024), "modal");
+
+  const snapshots = [
+    { items: [makeItem({ id: "story-alpha" })] },
+    { items: [makeItem({ id: "story-alpha" })] },
+    { items: [makeItem({ id: "story-beta" })] },
+  ];
+  const store = createBoardStore({
+    storage: null,
+    root: { addEventListener() {}, visibilityState: "visible" },
+    fetchJson: async () => snapshots.shift(),
+  });
+
+  await store.refresh();
+  store.setSelectedItem("story-alpha");
+  await store.refresh();
+  assert.equal(store.getState().selectedItemId, "story-alpha");
+
+  await store.refresh();
+  assert.equal(store.getState().selectedItemId, null);
+});

package/work-view/crates/cli/tests/board-js/markdown-filter.test.mjs

@@ -0,0 +1,60 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { installDomGlobals, loadBoardModule, makeItem } from "./harness.mjs";
+
+test("markdown renderer keeps adversarial HTML inert", async () => {
+  installDomGlobals();
+  const { renderMarkdown } = await loadBoardModule("markdown.js");
+  const root = renderMarkdown(`
+# Unsafe
+<script>alert("x")</script>
+<img src=x onerror=alert(1)>
+[bad](javascript:alert(1))
+[ok](https://example.com/docs)
+`);
+
+  assert.equal(root.querySelectorAll("script").length, 0);
+  assert.equal(root.querySelectorAll("img").length, 0);
+  assert.match(root.textContent, /<script>alert\("x"\)<\/script>/);
+  assert.match(root.textContent, /\[bad\]\(javascript:alert\(1\)\)/);
+
+  const anchors = root.querySelectorAll("a");
+  assert.equal(anchors.length, 1);
+  assert.equal(anchors[0].getAttribute("href"), "https://example.com/docs");
+  assert.equal(anchors[0].getAttribute("rel"), "noreferrer");
+});
+
+test("filters compose scalar ORs, group ANDs, tag ANDs, search, null parent, and tier hide", async () => {
+  installDomGlobals();
+  const { createDefaultFilters, matchesFilters } = await loadBoardModule("filters.js");
+  const item = makeItem({
+    kind: "story",
+    stage: "review",
+    parent: null,
+    tags: ["tooling", "testing"],
+    body: "Dependency board behavior",
+  });
+
+  const filters = createDefaultFilters();
+  filters.kinds = new Set(["feature", "story"]);
+  filters.stages = new Set(["done", "review"]);
+  filters.parents = new Set([""]);
+  filters.tags = new Set(["tooling", "testing"]);
+  filters.search = "dependency";
+  assert.equal(matchesFilters(item, filters), true);
+
+  filters.tags = new Set(["tooling", "missing"]);
+  assert.equal(matchesFilters(item, filters), false);
+
+  filters.tags = new Set(["tooling"]);
+  filters.kinds = new Set(["feature"]);
+  assert.equal(matchesFilters(item, filters), false);
+
+  filters.kinds = new Set(["story"]);
+  filters.autoHideReleased = true;
+  assert.equal(matchesFilters({ ...item, tier: "releases" }, filters), false);
+
+  filters.autoHideReleased = false;
+  assert.equal(matchesFilters({ ...item, tier: "releases" }, filters), true);
+});

package/work-view/crates/cli/tests/fixtures/golden/.work/CONVENTIONS.md

@@ -0,0 +1,3 @@
+# Conventions
+
+Test fixture substrate for the work-view CLI integration tests.

package/work-view/crates/cli/tests/fixtures/golden/.work/active/epics/epic-alpha.md

@@ -0,0 +1,16 @@
+---
+id: epic-alpha
+kind: epic
+stage: implementing
+tags: [tooling]
+parent: null
+depends_on: []
+release_binding: null
+gate_origin: null
+created: 2026-01-01
+updated: 2026-05-30
+---
+
+# Alpha epic
+
+Top-level epic for testing the CLI adapter.

package/work-view/crates/cli/tests/fixtures/golden/.work/active/features/feat-a.md

@@ -0,0 +1,16 @@
+---
+id: feat-a
+kind: feature
+stage: implementing
+tags: [tooling]
+parent: epic-alpha
+depends_on: []
+release_binding: v1.0.0
+gate_origin: null
+created: 2026-01-02
+updated: 2026-05-30
+---
+
+# Feature A
+
+First feature under the alpha epic.