beadcyte 0.4.0

package/src/web/projects.ts

@@ -0,0 +1,188 @@
+// projects.ts — the browser's list of beads project locations.
+//
+// Pure: no localStorage, no fetch, no Vue. The store owns persistence and
+// the server round-trip; this owns the format and the list operations, so
+// they can be tested without a browser.
+//
+// The list lives in the browser because it's a personal set of places on
+// this machine, like the watch list. The server still has to validate and
+// admit each path before it will read one (see src/projects.mjs) — this
+// side only remembers where the user said to look.
+
+export interface Project {
+  id: string;
+  label: string;
+  /** Canonical absolute path, as returned by the server on registration. */
+  path: string;
+}
+
+export const PROJECTS_STORAGE_KEY = "beadcyte:projects";
+export const ACTIVE_PROJECT_STORAGE_KEY = "beadcyte:project-active";
+
+/**
+ * Parse a stored registry. Anything malformed yields an empty list rather
+ * than throwing: a corrupt value must not take the app down on boot, and
+ * the launch project gets seeded back in immediately anyway.
+ *
+ * Entries without a usable path are dropped, duplicates by path collapse to
+ * the first, and order is preserved because the user set it.
+ */
+export function parseProjects(raw: string | null | undefined): Project[] {
+  if (!raw) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+
+  const out: Project[] = [];
+  const seenPath = new Set<string>();
+  const seenId = new Set<string>();
+  for (const entry of parsed) {
+    if (!entry || typeof entry !== "object") continue;
+    const e = entry as Record<string, unknown>;
+    const path = typeof e.path === "string" ? e.path.trim() : "";
+    if (!path || seenPath.has(path)) continue;
+    // A missing or colliding id is repairable; a missing path is not.
+    let id = typeof e.id === "string" && e.id.trim() ? e.id.trim() : "";
+    if (!id || seenId.has(id)) id = idForPath(path, seenId);
+    const label =
+      typeof e.label === "string" && e.label.trim()
+        ? e.label.trim()
+        : labelForPath(path);
+    seenPath.add(path);
+    seenId.add(id);
+    out.push({ id, label, path });
+  }
+  return out;
+}
+
+export function serializeProjects(list: readonly Project[]): string {
+  return JSON.stringify(list);
+}
+
+/** Last path segment, which is what a project is usually called. */
+export function labelForPath(path: string): string {
+  const parts = path.split("/").filter(Boolean);
+  return parts.length ? parts[parts.length - 1] : path;
+}
+
+/** Stable-ish id derived from the path, avoiding collisions in `taken`. */
+function idForPath(path: string, taken: ReadonlySet<string>): string {
+  const base = labelForPath(path).replace(/[^a-zA-Z0-9-]+/g, "-") || "project";
+  if (!taken.has(base)) return base;
+  for (let n = 2; ; n++) {
+    const candidate = `${base}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+
+/**
+ * Add a project, or return the list unchanged when the path is already
+ * known — re-adding a path the user already has should be a no-op rather
+ * than a duplicate row pointing at the same directory.
+ */
+export function addProject(
+  list: readonly Project[],
+  entry: { path: string; label?: string },
+): Project[] {
+  const path = entry.path.trim();
+  if (!path) return [...list];
+  if (list.some((p) => p.path === path)) return [...list];
+  const id = idForPath(path, new Set(list.map((p) => p.id)));
+  const label = entry.label?.trim() || labelForPath(path);
+  return [...list, { id, label, path }];
+}
+
+/**
+ * Which of the registry's paths the server does NOT currently admit.
+ *
+ * The two sides have deliberately different lifetimes: this list is
+ * persisted in localStorage because it records where the user looks, while
+ * the server's allowlist is per-process on purpose, so that restarting it
+ * does not inherit read permission from a previous session's browser state
+ * (see src/projects.mjs). The consequence is that after every server
+ * restart the client holds paths the server has forgotten, and reading one
+ * 403s. This is the diff the client has to close by re-registering.
+ */
+export function unadmittedPaths(
+  list: readonly Project[],
+  admitted: readonly string[] | null | undefined,
+): string[] {
+  const have = new Set(admitted ?? []);
+  return list.map((p) => p.path).filter((path) => !have.has(path));
+}
+
+export function removeProject(
+  list: readonly Project[],
+  id: string,
+): Project[] {
+  return list.filter((p) => p.id !== id);
+}
+
+export function renameProject(
+  list: readonly Project[],
+  id: string,
+  label: string,
+): Project[] {
+  const next = label.trim();
+  // An empty rename falls back to the path's own name rather than leaving a
+  // nameless row the user can't identify.
+  return list.map((p) =>
+    p.id === id ? { ...p, label: next || labelForPath(p.path) } : p,
+  );
+}
+
+/** Move an entry by `delta` places, clamped to the ends. */
+export function moveProject(
+  list: readonly Project[],
+  id: string,
+  delta: number,
+): Project[] {
+  const from = list.findIndex((p) => p.id === id);
+  if (from < 0) return [...list];
+  const to = Math.min(list.length - 1, Math.max(0, from + delta));
+  if (to === from) return [...list];
+  const next = [...list];
+  const [moved] = next.splice(from, 1);
+  next.splice(to, 0, moved);
+  return next;
+}
+
+/**
+ * Which project is active.
+ *
+ * `?project=` selects BY LABEL, not by path: a path in a URL is meaningless
+ * on another machine and leaks local filesystem layout into a shareable
+ * link. An unmatched label is ignored rather than clearing the selection.
+ *
+ * Falls back to the stored id, then the launch project, then the first
+ * entry — so there is always a selection when the list is non-empty.
+ */
+export function resolveActive(
+  list: readonly Project[],
+  opts: {
+    urlLabel?: string | null;
+    storedId?: string | null;
+    launchPath?: string | null;
+  } = {},
+): Project | null {
+  if (!list.length) return null;
+
+  const byLabel = opts.urlLabel
+    ? list.find((p) => p.label === opts.urlLabel)
+    : undefined;
+  if (byLabel) return byLabel;
+
+  const byId = opts.storedId
+    ? list.find((p) => p.id === opts.storedId)
+    : undefined;
+  if (byId) return byId;
+
+  const launch = opts.launchPath
+    ? list.find((p) => p.path === opts.launchPath)
+    : undefined;
+  return launch ?? list[0];
+}

package/src/web/refresh.ts

@@ -0,0 +1,47 @@
+// refresh.ts — the refresh-interval choices and their storage format.
+//
+// This bead owns the SETTING and where it's stored; bp-1kh owns the timer
+// that acts on it. Pure so the choices and their validation are testable.
+
+export const REFRESH_OFF = 0;
+
+/**
+ * Offered intervals, in ms. The default is deliberately slow: every tick
+ * shells out to `bd`, and this is a tool people leave open all day. "Off"
+ * is a first-class choice rather than an omission, because the header's
+ * "updated Ns ago" makes stale data visible enough to choose it safely.
+ */
+export const REFRESH_CHOICES: ReadonlyArray<{ ms: number; label: string }> = [
+  { ms: REFRESH_OFF, label: "off — manual only" },
+  { ms: 30_000, label: "30s" },
+  { ms: 60_000, label: "1m" },
+  { ms: 120_000, label: "2m" },
+  { ms: 300_000, label: "5m" },
+  { ms: 900_000, label: "15m" },
+];
+
+export const DEFAULT_REFRESH_MS = 120_000;
+
+export const REFRESH_STORAGE_KEY = "beadcyte:refresh-ms";
+
+/**
+ * Parse a stored interval. Anything that isn't one of the offered choices
+ * falls back to the default — including a plausible-looking number, because
+ * an arbitrary interval has no UI to display it and would look like the
+ * setting had been ignored.
+ */
+export function parseRefreshMs(raw: string | null | undefined): number {
+  if (raw === null || raw === undefined || raw === "") return DEFAULT_REFRESH_MS;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return DEFAULT_REFRESH_MS;
+  return REFRESH_CHOICES.some((c) => c.ms === n) ? n : DEFAULT_REFRESH_MS;
+}
+
+export function isRefreshOff(ms: number): boolean {
+  return ms === REFRESH_OFF;
+}
+
+/** Human label for an interval, for the header's status line. */
+export function refreshLabel(ms: number): string {
+  return REFRESH_CHOICES.find((c) => c.ms === ms)?.label ?? `${ms}ms`;
+}

package/src/web/search.ts

@@ -0,0 +1,50 @@
+// search.ts — ranking for the ⌘K palette.
+//
+// Extracted from SearchPalette.vue so the ranking rules are testable
+// without mounting a component (node:test can't mount .vue).
+
+export interface SearchableBead {
+  id: string;
+  title?: string | null;
+}
+
+export interface SearchResult<B extends SearchableBead> {
+  bead: B;
+  /** 3 = exact id, 2 = id prefix, 1 = title substring. 0 never surfaces. */
+  score: number;
+}
+
+/** Results shown at once; the palette is a jump target, not a report. */
+export const SEARCH_LIMIT = 20;
+
+/**
+ * Rank beads against a query, best first.
+ *
+ * An exact id beats an id prefix beats a title substring, so typing a full
+ * id always lands that bead at the top even when its id is a prefix of
+ * others (bp-1 vs bp-12). Ties keep input order, which is the caller's
+ * ordering (schedule order), not an arbitrary one — Array.sort is stable.
+ */
+export function rankBeads<B extends SearchableBead>(
+  beads: readonly B[],
+  query: string,
+  limit: number = SEARCH_LIMIT,
+): SearchResult<B>[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+
+  const scored: SearchResult<B>[] = [];
+  for (const bead of beads) {
+    const id = bead.id.toLowerCase();
+    const title = (bead.title ?? "").toLowerCase();
+
+    let score = 0;
+    if (id === q) score = 3;
+    else if (id.startsWith(q)) score = 2;
+    else if (title.includes(q)) score = 1;
+
+    if (score > 0) scored.push({ bead, score });
+  }
+
+  return scored.sort((a, b) => b.score - a.score).slice(0, limit);
+}

package/src/web/shortcuts.ts

@@ -0,0 +1,113 @@
+// shortcuts.ts — the MINE buttons: one click to "my ready work" or "my work
+// in review" (bp-egy).
+//
+// A shortcut is not a mode layered over the filters; it IS a filter state.
+// Clicking one replaces every filter term with the shortcut's own, so the
+// result never depends on what was selected before, and the popover pills
+// show exactly what is active. Whether a shortcut is "active" is therefore
+// derived: the current filters equal the shortcut's filters. Change any pill
+// by hand and the mark drops, which is the honest reading.
+//
+// The readiness rule itself (approved, workable status, unblocked) lives in
+// highlights.ts and is shared with the ready-now highlight. This module only
+// decides how that rule is expressed as filter terms, plus "assigned to me".
+//
+// Pure: no store, no DOM. The store supplies the current user and the
+// statuses present in the data.
+
+import type { Filters } from "./view-model";
+import { NOT_WORKABLE_STATUSES, READY_LABEL } from "./highlights.ts";
+
+/** Where the chosen current user is remembered between reloads. */
+export const CURRENT_USER_STORAGE_KEY = "beadcyte:current-user";
+
+export type Shortcut = "my-ready" | "my-review";
+
+export const SHORTCUT_IDS: readonly Shortcut[] = ["my-ready", "my-review"];
+
+export const SHORTCUTS: ReadonlyArray<{ id: Shortcut; label: string; title: string }> = [
+  {
+    id: "my-ready",
+    label: "ready work",
+    title:
+      "Assigned to you, carrying spec:ready, not finished or already moving, and with every blocker closed",
+  },
+  {
+    id: "my-review",
+    label: "in review",
+    title: "Assigned to you and in review",
+  },
+];
+
+/**
+ * The statuses "my ready work" keeps: everything this repo has that is not a
+ * finished, parked or already-moving status. Falls back to plain `open` when
+ * the data has no workable status at all, because an empty status selection
+ * would mean "every status" and show finished work as ready.
+ */
+export function workableStatuses(present: Iterable<string>): string[] {
+  const excluded = new Set<string>(NOT_WORKABLE_STATUSES);
+  const kept = [...new Set(present)].filter((s) => !excluded.has(s)).sort();
+  return kept.length ? kept : ["open"];
+}
+
+/**
+ * The complete filter state a shortcut stands for. Every key is set, so
+ * applying it replaces whatever was there.
+ */
+export function shortcutFilters(
+  kind: Shortcut,
+  me: string,
+  presentStatuses: Iterable<string>,
+): Filters {
+  switch (kind) {
+    case "my-ready":
+      return {
+        types: null,
+        priorities: null,
+        statuses: workableStatuses(presentStatuses),
+        labels: [READY_LABEL],
+        assignees: [me],
+        unblocked: true,
+      };
+    case "my-review":
+      return {
+        types: null,
+        priorities: null,
+        statuses: ["in_review"],
+        labels: null,
+        assignees: [me],
+        unblocked: null,
+      };
+  }
+}
+
+/**
+ * Does this filter state equal the shortcut's? Compared term by term with
+ * arrays order-insensitive and null / empty treated alike, since both mean
+ * "no constraint" to the view model.
+ */
+export function isShortcutActive(
+  filters: Filters,
+  kind: Shortcut,
+  me: string,
+  presentStatuses: Iterable<string>,
+): boolean {
+  const want = shortcutFilters(kind, me, presentStatuses);
+  return (
+    sameSet(filters.types, want.types) &&
+    sameSet(filters.priorities, want.priorities) &&
+    sameSet(filters.statuses, want.statuses) &&
+    sameSet(filters.labels, want.labels) &&
+    sameSet(filters.assignees, want.assignees) &&
+    !!filters.unblocked === !!want.unblocked
+  );
+}
+
+function sameSet<T>(a: T[] | null | undefined, b: T[] | null | undefined): boolean {
+  const aa = a ?? [];
+  const bb = b ?? [];
+  if (aa.length !== bb.length) return false;
+  const set = new Set(aa);
+  return bb.every((v) => set.has(v));
+}

package/src/web/status-filter.ts

@@ -0,0 +1,48 @@
+// status-filter.ts — what the status filter starts out selecting.
+//
+// Extracted from store.ts for the same reason window.ts was: the rule is
+// worth a test, and the store drags Pinia and a fetch into `node --test`.
+//
+// There used to be two boolean toggles — `showClosed` and `includeDeferred`
+// — applied ahead of the status filter and unconditionally. Asking for
+// `status=closed` with the toggle off returned an empty view and said nothing
+// about why, and no combination the toggles enabled was expressible only by
+// them. So they are gone, and what they used to enforce is now the initial
+// *value* of the filter they used to override (bp-67g.40).
+
+/**
+ * Statuses kept out of the first-paint selection.
+ *
+ * The timeline is normally about what is next, and in a mature project
+ * past-closed rows dominate the space. `tombstone` is here because a
+ * tombstoned bead is not work at all.
+ */
+export const STATUSES_HIDDEN_BY_DEFAULT = ["closed", "deferred", "tombstone"];
+
+/**
+ * The selection to start with, given the statuses a repo actually has.
+ *
+ * Enumerated from the data rather than from a fixed list, so a repo with no
+ * `blocked` beads never offers `blocked` — the same rule the other filter
+ * popovers follow.
+ *
+ * @param present   statuses observed on real (non-epic) beads
+ * @param alsoKeep  normally-hidden statuses to keep anyway, which is how a
+ *   legacy `?showClosed=true` link survives
+ * @returns the statuses to select, or null when there is nothing to seed
+ *   from yet — null means "no selection", which shows everything
+ */
+export function defaultStatusSelection(
+  present: Iterable<string>,
+  alsoKeep: readonly string[] = [],
+): string[] | null {
+  const all = [...new Set(present)];
+  if (all.length === 0) return null;
+  const keep = all.filter(
+    (s) => !STATUSES_HIDDEN_BY_DEFAULT.includes(s) || alsoKeep.includes(s),
+  );
+  // A repo of nothing but closed beads would otherwise open on an empty
+  // view, which reads as broken. Showing everything is at least legible, and
+  // the panel then says plainly that nothing is filtered out.
+  return keep.length ? keep : all;
+}