@pi-unipi/command-enchantment 2.4.0 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/command-enchantment",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Enhanced TUI autocomplete for /unipi:* commands — colored, sorted, and grouped by package",
   "type": "module",
   "main": "src/index.ts",
@@ -24,7 +24,9 @@
   ],
   "files": [
     "src/**/*.ts",
-    "README.md"
+    "README.md",
+    "!src/__tests__/**",
+    "!src/**/*.test.ts"
   ],
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/src/__tests__/command-registry.audit.test.ts

@@ -1,120 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { existsSync, globSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-function findRepoRoot(start: string): string {
-  let dir = start;
-  while (dir !== dirname(dir)) {
-    if (existsSync(join(dir, "packages", "autocomplete", "src", "constants.ts"))) return dir;
-    dir = dirname(dir);
-  }
-  return start;
-}
-
-const root = findRepoRoot(process.cwd());
-
-function read(path: string): string {
-  return readFileSync(join(root, path), "utf-8");
-}
-
-function collectConstants(): Map<string, string> {
-  const constants = new Map<string, string>([["UNIPI_PREFIX", "unipi:"]]);
-
-  for (const path of globSync("packages/**/*.ts", { cwd: root })) {
-    const text = read(path);
-    for (const obj of text.matchAll(/(?:export\s+)?const\s+(\w+)\s*=\s*\{([\s\S]*?)\}\s*as\s+const/g)) {
-      const [, name, body] = obj;
-      for (const item of body.matchAll(/(\w+):\s*"([^"]+)"/g)) {
-        constants.set(`${name}.${item[1]}`, item[2]);
-      }
-    }
-  }
-
-  return constants;
-}
-
-function evaluateCommandExpression(expr: string, constants: Map<string, string>): string | null {
-  const trimmed = expr.trim();
-
-  if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
-    const quote = trimmed[0];
-    const end = trimmed.indexOf(quote, 1);
-    return end > 0 ? trimmed.slice(1, end) : null;
-  }
-
-  if (trimmed.startsWith("`")) {
-    const end = trimmed.lastIndexOf("`");
-    if (end <= 0) return null;
-    return trimmed.slice(1, end).replace(/\$\{([^}]+)\}/g, (_match, key: string) => {
-      const resolved = constants.get(key.trim());
-      return resolved ?? `\${${key}}`;
-    });
-  }
-
-  return constants.get(trimmed) ?? null;
-}
-
-function registeredCommands(): { commands: Set<string>; nonUnipi: string[]; unresolved: string[] } {
-  const constants = collectConstants();
-  const commands = new Set<string>();
-  const nonUnipi: string[] = [];
-  const unresolved: string[] = [];
-
-  for (const path of globSync("packages/**/*.ts", { cwd: root }).sort()) {
-    const text = read(path);
-    if (!text.includes("registerCommand")) continue;
-
-    for (const match of text.matchAll(/\.registerCommand\(\s*([^,\n]+)/g)) {
-      const expr = match[1].trim();
-
-      // Workflow registers a loop over WORKFLOW_COMMANDS via local `fullCommand`.
-      if (path === "packages/workflow/commands.ts" && expr === "fullCommand") {
-        for (const [key, value] of constants) {
-          if (key.startsWith("WORKFLOW_COMMANDS.")) commands.add(`unipi:${value}`);
-        }
-        continue;
-      }
-
-      const command = evaluateCommandExpression(expr, constants);
-      if (!command || command.includes("${")) {
-        unresolved.push(`${path}: ${expr}`);
-        continue;
-      }
-
-      if (command.startsWith("unipi:")) {
-        commands.add(command);
-      } else {
-        nonUnipi.push(`${command} (${path})`);
-      }
-    }
-  }
-
-  return { commands, nonUnipi, unresolved };
-}
-
-function autocompleteRegistry(): { registry: Set<string>; descriptions: Set<string>; registryPackages: Set<string>; labels: Set<string> } {
-  const text = read("packages/autocomplete/src/constants.ts");
-  const registryBody = text.match(/export const COMMAND_REGISTRY[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
-  const descriptionsBody = text.match(/export const COMMAND_DESCRIPTIONS[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
-  const labelsBody = text.match(/export const PACKAGE_LABELS[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
-
-  const registry = new Set([...registryBody.matchAll(/"(unipi:[^"]+)"\s*:/g)].map((m) => m[1]));
-  const descriptions = new Set([...descriptionsBody.matchAll(/"(unipi:[^"]+)"\s*:/g)].map((m) => m[1]));
-  const registryPackages = new Set([...registryBody.matchAll(/"unipi:[^"]+"\s*:\s*"([^"]+)"/g)].map((m) => m[1]));
-  const labels = new Set([...labelsBody.matchAll(/^\s*"?([a-z][a-z0-9-]*)"?:\s*"/gm)].map((m) => m[1]));
-
-  return { registry, descriptions, registryPackages, labels };
-}
-
-describe("autocomplete command registry audit", () => {
-  it("mirrors every registered /unipi:* command and has no non-unipi package commands", () => {
-    const registered = registeredCommands();
-    const autocomplete = autocompleteRegistry();
-
-    expect(registered.unresolved, "unresolved registerCommand expressions").toEqual([]);
-    expect(registered.nonUnipi, "package commands must use the unipi: prefix").toEqual([]);
-    expect([...registered.commands].sort()).toEqual([...autocomplete.registry].sort());
-    expect([...autocomplete.registry].sort()).toEqual([...autocomplete.descriptions].sort());
-    expect([...autocomplete.registryPackages].filter((pkg) => !autocomplete.labels.has(pkg)).sort()).toEqual([]);
-  });
-});

package/src/__tests__/provider.sorting.test.ts

@@ -1,423 +0,0 @@
-/**
- * Tests for the 4-tier autocomplete command sorting model.
- *
- * Exercises crossItemPriority() and sortTaggedItems() from sorting.ts.
- * These are pure functions extracted from the provider closure for testability.
- */
-
-import { describe, it, expect } from "vitest";
-import {
-  crossItemPriority,
-  sortTaggedItems,
-  type TaggedItem,
-} from "../sorting.js";
-import type { AutocompleteItem } from "@earendil-works/pi-tui";
-
-// ─── Helpers ─────────────────────────────────────────────────────────
-
-/** Shorthand to create an AutocompleteItem. */
-function item(value: string, label?: string): AutocompleteItem {
-  return { value, label: label ?? value, description: "" };
-}
-
-/** Shorthand to create a TaggedItem. */
-function tagged(value: string, isUnipi: boolean, label?: string): TaggedItem {
-  return { item: item(value, label), isUnipi };
-}
-
-/** Extract just the values from a sorted TaggedItem[] for easy assertions. */
-function values(sorted: TaggedItem[]): string[] {
-  return sorted.map((t) => t.item.value);
-}
-
-// ═══════════════════════════════════════════════════════════════════════
-//  crossItemPriority — tier assignment
-// ═══════════════════════════════════════════════════════════════════════
-
-describe("crossItemPriority", () => {
-  // ── Tier 0: exact full-value match ──────────────────────────────────
-
-  it("assigns tier 0 for exact base command match", () => {
-    // query "new" matches item value "new" exactly
-    expect(crossItemPriority(item("new"), false, "new")).toBe(0);
-  });
-
-  it("assigns tier 0 for exact unipi full-value match", () => {
-    // query "unipi:brainstorm" matches item value "unipi:brainstorm"
-    expect(crossItemPriority(item("unipi:brainstorm"), true, "unipi:brainstorm")).toBe(0);
-  });
-
-  it("does NOT assign tier 0 for short-name-only match on unipi item", () => {
-    // query "brainstorm" is not the full value "unipi:brainstorm"
-    expect(crossItemPriority(item("unipi:brainstorm"), true, "brainstorm")).not.toBe(0);
-  });
-
-  // ── Tier 1: unipi short-name exact match ────────────────────────────
-
-  it("assigns tier 1 when unipi short name matches query exactly", () => {
-    expect(crossItemPriority(item("unipi:brainstorm"), true, "brainstorm")).toBe(1);
-  });
-
-  it("does NOT assign tier 1 for non-unipi items", () => {
-    // "new" is not a unipi item, so short === full === "new", which is tier 0 (exact)
-    expect(crossItemPriority(item("new"), false, "new")).toBe(0);
-  });
-
-  it("does NOT assign tier 1 when unipi short name doesn't match", () => {
-    expect(crossItemPriority(item("unipi:brainstorm"), true, "brain")).not.toBeLessThanOrEqual(1);
-  });
-
-  // ── Tier 2: prefix match ────────────────────────────────────────────
-
-  it("assigns tier 2 for base prefix match", () => {
-    expect(crossItemPriority(item("work"), false, "wor")).toBe(2);
-  });
-
-  it("assigns tier 2 for unipi short-name prefix match", () => {
-    // short = "work", query = "wor" → startsWith → tier 2
-    expect(crossItemPriority(item("unipi:work"), true, "wor")).toBe(2);
-  });
-
-  it("assigns tier 2 when full value has prefix (unipi: prefix)", () => {
-    // full = "unipi:compact", query = "unipi:co" → startsWith → tier 2
-    expect(crossItemPriority(item("unipi:compact"), true, "unipi:co")).toBe(2);
-  });
-
-  // ── Tier 3: fuzzy fallback ──────────────────────────────────────────
-
-  it("assigns tier 3 for fuzzy-only match", () => {
-    // "review-work" doesn't start with "wor" but contains characters
-    expect(crossItemPriority(item("unipi:review-work"), true, "wor")).toBe(3);
-  });
-
-  it("assigns tier 3 for character subsequence match", () => {
-    // "fix" is a subsequence of... no wait, let's use "fx" vs "fix"
-    // "fix" contains f, i, x. query "fx" → f...x → subsequence → tier 3
-    expect(crossItemPriority(item("fix"), false, "fx")).toBe(3);
-  });
-
-  it("assigns tier 3 for non-matching query (all items get tier 3)", () => {
-    expect(crossItemPriority(item("brainstorm"), false, "xyz")).toBe(3);
-  });
-
-  // ── Case insensitivity ──────────────────────────────────────────────
-
-  it("matches case-insensitively (tier 0)", () => {
-    expect(crossItemPriority(item("new"), false, "New")).toBe(0);
-    expect(crossItemPriority(item("New"), false, "new")).toBe(0);
-  });
-
-  it("matches case-insensitively (tier 2)", () => {
-    expect(crossItemPriority(item("Compact"), false, "co")).toBe(2);
-  });
-
-  it("matches case-insensitively (tier 1)", () => {
-    expect(crossItemPriority(item("unipi:Brainstorm"), true, "brainstorm")).toBe(1);
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════
-//  sortTaggedItems — cross-group merge sort
-// ═══════════════════════════════════════════════════════════════════════
-
-describe("sortTaggedItems", () => {
-  // ── Test 1: Exact base command before fuzzy unipi ───────────────────
-
-  it("ranks exact base command (tier 0) before fuzzy unipi (tier 3)", () => {
-    const items = [
-      tagged("unipi:review-work", true), // tier 3 (r→e→w fuzzy)
-      tagged("new", false),              // tier 0 (exact)
-    ];
-
-    const sorted = sortTaggedItems(items, "new");
-    expect(values(sorted)).toEqual(["new", "unipi:review-work"]);
-  });
-
-  // ── Test 2: Unipi short-name exact (tier 1) ────────────────────────
-
-  it("ranks unipi short-name exact (tier 1) above prefix and fuzzy", () => {
-    const items = [
-      tagged("unipi:brainstorm", true), // tier 1
-      tagged("unipi:plan", true),       // tier 3 (no b-r-a-i-n)
-    ];
-
-    const sorted = sortTaggedItems(items, "brainstorm");
-    expect(sorted[0].item.value).toBe("unipi:brainstorm");
-    expect(crossItemPriority(items[0].item, true, "brainstorm")).toBe(1);
-  });
-
-  // ── Test 3: Full unipi exact (tier 0) ──────────────────────────────
-
-  it("ranks full unipi: value exact match as tier 0", () => {
-    const items = [
-      tagged("unipi:brainstorm", true),
-      tagged("brainstorm", false), // also tier 0 exact on value
-    ];
-
-    const sorted = sortTaggedItems(items, "unipi:brainstorm");
-    // Both could be tier 0 or fuzzy. unipi:brainstorm is tier 0 (exact full).
-    // "brainstorm" as base: full "brainstorm" !== "unipi:brainstorm" → not tier 0
-    // full.startsWith query? "brainstorm".startsWith("unipi:brainstorm") → no
-    // So "brainstorm" gets tier 3
-    expect(sorted[0].item.value).toBe("unipi:brainstorm");
-  });
-
-  // ── Test 4: Prefix match ordering (non-unipi before unipi) ─────────
-
-  it("within same tier, sorts non-unipi before unipi", () => {
-    const items = [
-      tagged("unipi:work", true),  // tier 2 (prefix "wor" → "work")
-      tagged("work", false),       // tier 2 (prefix "wor" → "work")
-    ];
-
-    const sorted = sortTaggedItems(items, "wor");
-    expect(values(sorted)).toEqual(["work", "unipi:work"]);
-  });
-
-  // ── Test 5: Fuzzy sorted by similarity (shorter name first) ────────
-
-  it("within tier 3 fuzzy, shorter names sort first", () => {
-    const items = [
-      tagged("unipi:review-work", true), // longer
-      tagged("fix", false),              // shorter
-      tagged("unipi:fix", true),         // medium
-    ];
-
-    const sorted = sortTaggedItems(items, "fx");
-    // All tier 3 fuzzy. Sorted by: non-unipi first, then by length.
-    // "fix" (len 3, non-unipi) → "unipi:fix" (len 9, unipi) → "unipi:review-work" (len 17, unipi)
-    expect(values(sorted)).toEqual(["fix", "unipi:fix", "unipi:review-work"]);
-  });
-
-  // ── Test 6: Mixed tiers ────────────────────────────────────────────
-
-  it("sorts across mixed tiers: exact → prefix → fuzzy", () => {
-    const items = [
-      tagged("unipi:compact", true),    // tier 2 (prefix "co")
-      tagged("compact-xyz", false),     // tier 2 (prefix "co")
-      tagged("co", false),              // tier 0 (exact "co")
-      tagged("unipi:consultant", true), // tier 2 (prefix "co")
-      tagged("config", false),          // tier 2 (prefix "co")
-      tagged("unipi:chore-create", true), // tier 3 (fuzzy c→o)
-    ];
-
-    const sorted = sortTaggedItems(items, "co");
-    // Tier 0: co
-    // Tier 2: compact-xyz, config (non-unipi) then unipi:compact, unipi:consultant (unipi)
-    // Tier 3: unipi:chore-create
-    const result = values(sorted);
-    expect(result[0]).toBe("co");
-    // Tier 2 non-unipi
-    expect(result.slice(1, 3)).toEqual(expect.arrayContaining(["compact-xyz", "config"]));
-    // Tier 2 unipi
-    expect(result.slice(3, 5)).toEqual(expect.arrayContaining(["unipi:compact", "unipi:consultant"]));
-    // Tier 3
-    expect(result[5]).toBe("unipi:chore-create");
-  });
-
-  // ── Test 7: No base command match, only unipi ──────────────────────
-
-  it("handles unipi-only matches (tier 1 short-name exact)", () => {
-    const items = [
-      tagged("unipi:ralph", true),     // tier 1 (short "ralph" === "ralph")
-      tagged("unipi:ralph-stop", true), // tier 2 (prefix "ralph")
-    ];
-
-    const sorted = sortTaggedItems(items, "ralph");
-    expect(values(sorted)).toEqual(["unipi:ralph", "unipi:ralph-stop"]);
-  });
-
-  // ── Test 8: Skill commands filtered (simulated: skill: items present) ─
-
-  it("sortItems does not filter skill commands — that's the provider's job", () => {
-    // The sorting function itself is pure — it just sorts whatever it receives.
-    // Skill filtering happens at the provider level. Verify sorting handles them.
-    // Note: "skill:animate" does NOT start with "a", so it gets tier 3 (fuzzy).
-    // "unipi:auto" short name "auto" starts with "a" → tier 2 (prefix).
-    const items = [
-      tagged("skill:animate", false),
-      tagged("skill:audit", false),
-      tagged("unipi:auto", true),
-    ];
-
-    const sorted = sortTaggedItems(items, "a");
-    // unipi:auto (tier 2) before skill: items (tier 3)
-    // Within tier 3: non-unipi, sorted by length: audit(11) < animate(13)
-    expect(values(sorted)).toEqual(["unipi:auto", "skill:audit", "skill:animate"]);
-  });
-
-  // ── Test 9: Skill query scenario ───────────────────────────────────
-
-  it("when skill: prefix items are present, they sort by tier like any other", () => {
-    // "skill:work" does NOT start with "work" → tier 3 (fuzzy)
-    // "unipi:work" short name "work" starts with "work" → tier 2 (prefix)
-    const items = [
-      tagged("skill:work", false),       // tier 3 (fuzzy)
-      tagged("unipi:work", true),        // tier 2 (prefix)
-      tagged("skill:workshop", false),   // tier 3 (fuzzy)
-    ];
-
-    const sorted = sortTaggedItems(items, "work");
-    // unipi:work (tier 2) before skill items (tier 3)
-    // Within tier 3: non-unipi, sorted by length: skill:work(11) < skill:workshop(15)
-    expect(values(sorted)).toEqual(["unipi:work", "skill:work", "skill:workshop"]);
-  });
-
-  // ── Test 10: Empty query ───────────────────────────────────────────
-
-  it("empty query gives all items tier 0 (exact on empty string)", () => {
-    // When query is "", every value matches exactly: "".startsWith("") → true
-    // Actually: full === "" is false for non-empty values. But "".startsWith("") is true → tier 2
-    // Wait: full === q where q = "". If value is "new", full="new" !== "" → not tier 0.
-    // short.startsWith("") → true → tier 2.
-    // So all items get tier 2 when query is "".
-    // Within tier 2: non-unipi first, then stable.
-    const items = [
-      tagged("unipi:brain", true),
-      tagged("new", false),
-      tagged("unipi:work", true),
-      tagged("fix", false),
-    ];
-
-    const sorted = sortTaggedItems(items, "");
-    // All tier 2. Non-unipi first (preserving original order), then unipi.
-    expect(values(sorted)).toEqual(["new", "fix", "unipi:brain", "unipi:work"]);
-  });
-
-  // ── Test 11: Case insensitive ──────────────────────────────────────
-
-  it("matches case-insensitively across tiers", () => {
-    const items = [
-      tagged("unipi:Brainstorm", true),
-      tagged("New", false),
-    ];
-
-    // query "/New" stripped → "new"
-    const sorted = sortTaggedItems(items, "new");
-    expect(sorted[0].item.value).toBe("New"); // tier 0 exact (case-insensitive)
-
-    // query "BRAINSTORM" → unipi short-name "brainstorm" exact (case-insensitive)
-    const sorted2 = sortTaggedItems(items, "BRAINSTORM");
-    expect(sorted2[0].item.value).toBe("unipi:Brainstorm"); // tier 1
-  });
-
-  // ── Test 12: Stable sort ───────────────────────────────────────────
-
-  it("preserves original order for items at same tier and same source", () => {
-    const items = [
-      tagged("alpha", false),     // tier 2 (prefix "a")
-      tagged("unipi:a-first", true),  // tier 2
-      tagged("beta", false),      // tier 2
-      tagged("unipi:a-second", true), // tier 2
-      tagged("gamma", false),     // tier 2
-    ];
-
-    const sorted = sortTaggedItems(items, "a");
-    const result = values(sorted);
-
-    // Non-unipi items preserve their original relative order: alpha, beta, gamma
-    const nonUnipi = result.filter((v) => !v.startsWith("unipi:"));
-    expect(nonUnipi).toEqual(["alpha", "beta", "gamma"]);
-
-    // Unipi items preserve their original relative order: a-first, a-second
-    const unipiItems = result.filter((v) => v.startsWith("unipi:"));
-    expect(unipiItems).toEqual(["unipi:a-first", "unipi:a-second"]);
-  });
-
-  // ── Test 13: btw:new scenario ──────────────────────────────────────
-
-  it("btw:new gets tier 3 fuzzy for query 'new' (not prefix match)", () => {
-    // "btw:new" does NOT start with "new" → not tier 2
-    // "btw:new" !== "new" → not tier 0
-    // fuzzy match: b...t...w...:...n...e...w → "new" is subsequence → tier 3
-    const items = [
-      tagged("btw:new", false),     // tier 3
-      tagged("new", false),         // tier 0
-      tagged("unipi:new-thing", true), // tier 2 (prefix "new")
-    ];
-
-    const sorted = sortTaggedItems(items, "new");
-    expect(values(sorted)).toEqual(["new", "unipi:new-thing", "btw:new"]);
-  });
-
-  it("verifies btw:new is tier 3 for query 'new'", () => {
-    expect(crossItemPriority(item("btw:new"), false, "new")).toBe(3);
-  });
-
-  it("verifies 'new' is tier 0 for query 'new'", () => {
-    expect(crossItemPriority(item("new"), false, "new")).toBe(0);
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════
-//  Additional edge cases
-// ═══════════════════════════════════════════════════════════════════════
-
-describe("edge cases", () => {
-  it("handles single item", () => {
-    const items = [tagged("new", false)];
-    const sorted = sortTaggedItems(items, "new");
-    expect(values(sorted)).toEqual(["new"]);
-  });
-
-  it("handles empty input array", () => {
-    const sorted = sortTaggedItems([], "new");
-    expect(sorted).toEqual([]);
-  });
-
-  it("does not mutate the original array", () => {
-    const original = [tagged("b", false), tagged("a", false)];
-    const copy = [...original];
-    sortTaggedItems(original, "a");
-    expect(original).toEqual(copy);
-  });
-
-  it("sorts multiple tier 0 exact matches (non-unipi before unipi)", () => {
-    const items = [
-      tagged("unipi:abc", true), // tier 0 (full value "unipi:abc" === query)
-      tagged("unipi:abc", false), // tier 0 (but isUnipi=false, value doesn't start with "unipi:")
-    ];
-
-    // Both have value "unipi:abc", but one is tagged isUnipi=true
-    // Wait: the non-unipi one has value "unipi:abc" — that's unusual but possible
-    // crossItemPriority: full="unipi:abc" === "unipi:abc" → tier 0 for both
-    // Same tier → non-unipi first
-    const sorted = sortTaggedItems(items, "unipi:abc");
-    expect(sorted[0].isUnipi).toBe(false);
-    expect(sorted[1].isUnipi).toBe(true);
-  });
-
-  it("tier 3 sorts by length, non-unipi first within same length", () => {
-    const items = [
-      tagged("unipi:ab", true),   // len 9, tier 3
-      tagged("cd", false),        // len 2, tier 3
-      tagged("ef", false),        // len 2, tier 3
-      tagged("unipi:gh", true),   // len 9, tier 3
-    ];
-
-    const sorted = sortTaggedItems(items, "z");
-    // All tier 3. Non-unipi first (by length within non-unipi): cd(2), ef(2)
-    // Then unipi (by length): unipi:ab(9), unipi:gh(9)
-    const result = values(sorted);
-    expect(result.slice(0, 2)).toEqual(["cd", "ef"]);
-    expect(result.slice(2, 4)).toEqual(["unipi:ab", "unipi:gh"]);
-  });
-
-  it("handles query matching full unipi prefix + partial short name", () => {
-    // query "unipi:bra" → full "unipi:brainstorm".startsWith("unipi:bra") → tier 2
-    expect(crossItemPriority(item("unipi:brainstorm"), true, "unipi:bra")).toBe(2);
-  });
-
-  it("unipi item with tier 1 beats base item with tier 2", () => {
-    const items = [
-      tagged("work", false),           // tier 2 (prefix "brain"... no)
-      tagged("unipi:brainstorm", true), // tier 1 (short exact)
-    ];
-
-    // query "brainstorm": 
-    // "work" → full "work" !== "brainstorm", !startsWith → tier 3
-    // "unipi:brainstorm" → short "brainstorm" === "brainstorm" → tier 1
-    const sorted = sortTaggedItems(items, "brainstorm");
-    expect(values(sorted)).toEqual(["unipi:brainstorm", "work"]);
-  });
-});