@korso/shepherd-ui 0.2.0 → 0.2.1

package/dist/views/wallboard.js

@@ -1,209 +0,0 @@
-// ---------------------------------------------------------------------------
-// wallboard — pure helpers ported from packages/hub/public/app.js, the vanilla
-// wallboard the React Tasks/Chat views replace. These mirror that module's
-// behavior exactly so the board reads the same data the same way (functional
-// parity). No DOM, no clock: every helper takes `nowMs` so countdowns/relative
-// times are computed against the server's clock (landscape.serverTime), not the
-// browser's, keeping them correct under skew — same as the old page did.
-// ---------------------------------------------------------------------------
-/** Human "N ago" for a past ISO timestamp, relative to nowMs (epoch ms). */
-export function formatRelative(iso, nowMs) {
-    const secs = Math.floor((nowMs - Date.parse(iso)) / 1000);
-    if (secs < 5)
-        return "just now";
-    if (secs < 60)
-        return `${secs}s ago`;
-    const mins = Math.floor(secs / 60);
-    if (mins < 60)
-        return `${mins}m ago`;
-    const hrs = Math.floor(mins / 60);
-    if (hrs < 24)
-        return `${hrs}h ago`;
-    return `${Math.floor(hrs / 24)}d ago`;
-}
-/**
- * Deterministic chat color for an agent name — same name always maps to the
- * same hue, so each speaker reads consistently across the announcement thread.
- */
-export function colorForName(name) {
-    let h = 0;
-    for (let i = 0; i < name.length; i++)
-        h = (h * 31 + name.charCodeAt(i)) % 360;
-    return `hsl(${h}, 38%, 42%)`;
-}
-/**
- * Up to two initials for an avatar. Prefers the capital letters of a CamelCase
- * agent name (RedDragon → RD); otherwise the first two letters (alice → AL).
- */
-export function initialsFor(name) {
-    if (!name)
-        return "?";
-    const caps = name.match(/[A-Z]/g);
-    if (caps && caps.length >= 2)
-        return caps[0] + caps[1];
-    return name.slice(0, 2).toUpperCase();
-}
-/** Human label for a history task's status. */
-export function statusLabel(status) {
-    return status === "dropped" ? "dropped" : "done";
-}
-/** "active Nm/Nh" for the created->ended span; "" when the task hasn't ended. */
-export function formatActiveDuration(createdIso, endedIso) {
-    if (!endedIso)
-        return "";
-    const secs = Math.floor((Date.parse(endedIso) - Date.parse(createdIso)) / 1000);
-    const mins = Math.floor(secs / 60);
-    if (mins < 60)
-        return `active ${mins}m`;
-    return `active ${Math.floor(mins / 60)}h`;
-}
-/** Local-day bucket label: "Today" / "Yesterday" / "Mon D". */
-export function dayBucket(iso, nowMs) {
-    const d = new Date(Date.parse(iso));
-    const now = new Date(nowMs);
-    const startOf = (x) => new Date(x.getFullYear(), x.getMonth(), x.getDate()).getTime();
-    const dayDiff = Math.round((startOf(now) - startOf(d)) / 86400000);
-    if (dayDiff <= 0)
-        return "Today";
-    if (dayDiff === 1)
-        return "Yesterday";
-    return d.toLocaleDateString(undefined, { month: "short", day: "numeric" });
-}
-// ---------------------------------------------------------------------------
-// Glob containment + active-claim grouping (verbatim from app.js, retyped)
-// ---------------------------------------------------------------------------
-/**
- * Normalize a glob into a segment list. Mirrors the server's normalize
- * (packages/hub/src/globs.ts) so the two agree on path shape.
- */
-function normalizeGlob(pattern) {
-    let p = pattern.toLowerCase().replace(/\\/g, "/");
-    if (p.endsWith("/"))
-        p = p.replace(/\/+$/, "") + "/**";
-    const out = [];
-    for (const seg of p.split("/")) {
-        if (seg === "" || seg === ".")
-            continue;
-        if (seg === "..") {
-            if (out.length)
-                out.pop();
-            continue;
-        }
-        out.push(seg);
-    }
-    return out;
-}
-const SEG_WILDCARD = /[*?{}[\]]/;
-/** Does single-segment pattern `a` cover single-segment pattern `b`? */
-function segmentCovers(a, b) {
-    if (a === "*")
-        return true;
-    if (SEG_WILDCARD.test(a))
-        return a === b;
-    return !SEG_WILDCARD.test(b) && a === b;
-}
-/** Does pattern A (segments) cover pattern B (segments)? '**' consumes 0+ segments. */
-function patternCovers(a, b) {
-    const memo = new Map();
-    function go(i, j) {
-        if (b.length - j === 0) {
-            for (let k = i; k < a.length; k++)
-                if (a[k] !== "**")
-                    return false;
-            return true;
-        }
-        if (a.length - i === 0)
-            return false;
-        const key = i * (b.length + 1) + j;
-        const cached = memo.get(key);
-        if (cached !== undefined)
-            return cached;
-        const ah = a[i], bh = b[j];
-        let res;
-        if (ah === "**") {
-            res = go(i + 1, j) || go(i, j + 1);
-        }
-        else if (bh === "**") {
-            res = false;
-        }
-        else {
-            res = segmentCovers(ah, bh) && go(i + 1, j + 1);
-        }
-        memo.set(key, res);
-        return res;
-    }
-    return go(0, 0);
-}
-/**
- * Does glob set `outer` fully cover glob set `inner`? Conservative: unsure → false,
- * so a claim only folds when it is certainly contained. Empty `inner` is covered.
- */
-export function globsCover(outer, inner) {
-    if (inner.length === 0)
-        return true;
-    const o = outer.map(normalizeGlob);
-    return inner.every((g) => {
-        const ng = normalizeGlob(g);
-        return o.some((op) => patternCovers(op, ng));
-    });
-}
-/**
- * Group active claims by agent for the board. Within an agent's claims, one that
- * is STRICTLY covered by a broader sibling folds into `narrower`; everything else
- * stays a visible `primary`. Groups + claims are newest-first; header fields come
- * from the group's newest claim. Pure — no DOM, no clock.
- */
-export function groupActiveClaims(tasks) {
-    const byAgent = new Map();
-    for (const t of tasks) {
-        if (!byAgent.has(t.agentName))
-            byAgent.set(t.agentName, []);
-        byAgent.get(t.agentName).push(t);
-    }
-    const newestFirst = (a, b) => b.createdAt.localeCompare(a.createdAt);
-    const groups = [];
-    for (const [agentName, claims] of byAgent) {
-        const sorted = [...claims].sort(newestFirst);
-        const isNarrower = sorted.map((c) => sorted.some((o) => o !== c &&
-            globsCover(o.pathGlobs, c.pathGlobs) &&
-            !globsCover(c.pathGlobs, o.pathGlobs)));
-        const head = sorted[0];
-        groups.push({
-            agentName,
-            model: head.model,
-            program: head.program,
-            repo: head.repo,
-            primaries: sorted.filter((_, i) => !isNarrower[i]),
-            narrower: sorted.filter((_, i) => isNarrower[i]),
-        });
-    }
-    groups.sort((g1, g2) => {
-        const t1 = g1.primaries.concat(g1.narrower)[0].createdAt;
-        const t2 = g2.primaries.concat(g2.narrower)[0].createdAt;
-        return t2.localeCompare(t1);
-    });
-    return groups;
-}
-// ---------------------------------------------------------------------------
-// @mention target extraction (composer → DM direction). Ported from app.js so a
-// typed @name still directs the message, matching the old send behavior. The
-// autocomplete POPUP UI is intentionally not ported (visual polish, deferred).
-// ---------------------------------------------------------------------------
-/** Characters allowed in an agent-name mention token. */
-const MENTION_CHARS = "A-Za-z0-9_-";
-/**
- * The first `@mention` in `text` matching a known agent name, returned in the
- * name's canonical casing (`@reddragon` → `RedDragon`), or null when none match.
- * An unmatched `@foo` is plain text and the message broadcasts.
- */
-export function extractTarget(text, knownNames) {
-    const re = new RegExp(`(?:^|\\s)@([${MENTION_CHARS}]+)`, "g");
-    let m;
-    while ((m = re.exec(text)) !== null) {
-        const typed = m[1].toLowerCase();
-        const hit = knownNames.find((n) => n.toLowerCase() === typed);
-        if (hit)
-            return hit;
-    }
-    return null;
-}

package/dist/views/wallboard.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/views/wallboard.test.js

@@ -1,143 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatRelative, statusLabel, formatActiveDuration, dayBucket, initialsFor, colorForName, globsCover, groupActiveClaims, extractTarget, } from "./wallboard.js";
-// ---------------------------------------------------------------------------
-// wallboard helpers — the pure logic ported from packages/hub/public/app.js,
-// driving the React Tasks/Chat views. Mirrors that module's behavior so the
-// ported board reads the same data the same way (functional parity).
-// ---------------------------------------------------------------------------
-function task(over = {}) {
-    return {
-        agentName: "alice",
-        program: "claude",
-        model: "opus",
-        repo: "acme/web",
-        intent: "do a thing",
-        pathGlobs: ["src/**"],
-        status: "active",
-        createdAt: "2026-06-29T00:00:00.000Z",
-        endedAt: null,
-        ...over,
-    };
-}
-describe("formatRelative", () => {
-    const now = Date.parse("2026-06-29T01:00:00.000Z");
-    it("says 'just now' under 5s", () => {
-        expect(formatRelative("2026-06-29T00:59:58.000Z", now)).toBe("just now");
-    });
-    it("renders seconds / minutes / hours / days", () => {
-        expect(formatRelative("2026-06-29T00:59:30.000Z", now)).toBe("30s ago");
-        expect(formatRelative("2026-06-29T00:30:00.000Z", now)).toBe("30m ago");
-        expect(formatRelative("2026-06-28T22:00:00.000Z", now)).toBe("3h ago");
-        expect(formatRelative("2026-06-26T01:00:00.000Z", now)).toBe("3d ago");
-    });
-});
-describe("statusLabel", () => {
-    it("maps dropped → dropped, everything else → done", () => {
-        expect(statusLabel("dropped")).toBe("dropped");
-        expect(statusLabel("done")).toBe("done");
-    });
-});
-describe("formatActiveDuration", () => {
-    it("is empty when not ended", () => {
-        expect(formatActiveDuration("2026-06-29T00:00:00.000Z", null)).toBe("");
-    });
-    it("renders minutes then hours", () => {
-        expect(formatActiveDuration("2026-06-29T00:00:00.000Z", "2026-06-29T00:30:00.000Z")).toBe("active 30m");
-        expect(formatActiveDuration("2026-06-29T00:00:00.000Z", "2026-06-29T03:00:00.000Z")).toBe("active 3h");
-    });
-});
-describe("dayBucket", () => {
-    const now = Date.parse("2026-06-29T12:00:00.000Z");
-    it("buckets today / yesterday", () => {
-        expect(dayBucket("2026-06-29T08:00:00.000Z", now)).toBe("Today");
-        expect(dayBucket("2026-06-28T08:00:00.000Z", now)).toBe("Yesterday");
-    });
-});
-describe("initialsFor", () => {
-    it("prefers two capitals of a CamelCase name", () => {
-        expect(initialsFor("RedDragon")).toBe("RD");
-    });
-    it("falls back to the first two letters", () => {
-        expect(initialsFor("alice")).toBe("AL");
-    });
-    it("handles empty", () => {
-        expect(initialsFor("")).toBe("?");
-    });
-});
-describe("groupActiveClaims", () => {
-    it("groups claims by agent", () => {
-        const groups = groupActiveClaims([
-            task({ agentName: "alice", pathGlobs: ["a/**"] }),
-            task({ agentName: "bob", pathGlobs: ["b/**"] }),
-        ]);
-        expect(groups.map((g) => g.agentName).sort()).toEqual(["alice", "bob"]);
-    });
-    it("folds a strictly-covered claim into narrower", () => {
-        const groups = groupActiveClaims([
-            task({
-                agentName: "alice",
-                pathGlobs: ["src/**"],
-                createdAt: "2026-06-29T00:00:00.000Z",
-            }),
-            task({
-                agentName: "alice",
-                pathGlobs: ["src/a.ts"],
-                createdAt: "2026-06-29T00:01:00.000Z",
-            }),
-        ]);
-        expect(groups).toHaveLength(1);
-        const g = groups[0];
-        expect(g.primaries.map((p) => p.pathGlobs)).toEqual([["src/**"]]);
-        expect(g.narrower.map((p) => p.pathGlobs)).toEqual([["src/a.ts"]]);
-    });
-});
-describe("colorForName", () => {
-    it("is deterministic — the same name always maps to the same hue", () => {
-        expect(colorForName("RedDragon")).toBe(colorForName("RedDragon"));
-    });
-    it("distinguishes different names", () => {
-        expect(colorForName("alice")).not.toBe(colorForName("bob"));
-    });
-    it("returns a well-formed hsl() string", () => {
-        expect(colorForName("alice")).toMatch(/^hsl\(\d+, 38%, 42%\)$/);
-    });
-});
-describe("globsCover", () => {
-    it("treats an empty inner set as covered", () => {
-        expect(globsCover(["src/**"], [])).toBe(true);
-    });
-    it("covers a literal under a '**' wildcard", () => {
-        expect(globsCover(["src/**"], ["src/a.ts"])).toBe(true);
-    });
-    it("does not cover across a path segment with a single '*'", () => {
-        // '*' is a single-segment wildcard: it must not span the '/'.
-        expect(globsCover(["src/*"], ["src/a/b.ts"])).toBe(false);
-    });
-    it("lets '**' span multiple path segments", () => {
-        expect(globsCover(["**"], ["src/deep/nested/file.ts"])).toBe(true);
-    });
-    it("matches a literal segment exactly, not a wildcard sibling", () => {
-        expect(globsCover(["src/a.ts"], ["src/a.ts"])).toBe(true);
-        expect(globsCover(["src/a.ts"], ["src/b.ts"])).toBe(false);
-    });
-    it("does not let a narrower literal cover a wildcard", () => {
-        expect(globsCover(["src/a.ts"], ["src/*"])).toBe(false);
-    });
-    it("normalizes '.' and '..' segments before comparing", () => {
-        // "src/foo/../**" normalizes to "src/**", which covers "src/a.ts".
-        expect(globsCover(["src/foo/../**"], ["src/a.ts"])).toBe(true);
-    });
-    it("requires every inner glob to be covered by some outer glob", () => {
-        expect(globsCover(["src/**"], ["src/a.ts", "lib/b.ts"])).toBe(false);
-        expect(globsCover(["src/**", "lib/**"], ["src/a.ts", "lib/b.ts"])).toBe(true);
-    });
-});
-describe("extractTarget", () => {
-    it("resolves the first @mention matching a known name, canonical-cased", () => {
-        expect(extractTarget("hey @reddragon look", ["RedDragon", "alice"])).toBe("RedDragon");
-    });
-    it("returns null when no mention matches", () => {
-        expect(extractTarget("no mention here", ["alice"])).toBeNull();
-        expect(extractTarget("hi @nobody", ["alice"])).toBeNull();
-    });
-});