@blackbelt-technology/pi-agent-dashboard 0.5.1 → 0.5.2

package/packages/shared/src/types.ts

@@ -404,6 +404,40 @@ export interface OpenSpecChange {
    * "Archive anyway" escape hatch when artifacts are authored but tasks remain unchecked.
    */
   isComplete?: boolean;
+  /**
+   * Group assignment joined server-side from `<cwd>/openspec/groups/groups.json`.
+   * `null` or absent means Ungrouped. Clients SHALL NOT recompute the join.
+   * See change: add-openspec-change-grouping.
+   */
+  groupId?: string | null;
+}
+
+/** Schema version for the per-repo OpenSpec groups file at
+ *  `<cwd>/openspec/groups/groups.json`. Bumped only on incompatible shape changes.
+ *  See change: add-openspec-change-grouping. */
+export const OPENSPEC_GROUPS_SCHEMA_VERSION = 1 as const;
+
+/** A user-defined group of OpenSpec changes within a single repo.
+ *  See change: add-openspec-change-grouping. */
+export interface OpenSpecGroup {
+  /** Server-generated slug from `name` plus collision suffix. Stable across rename. */
+  id: string;
+  /** User-visible label; editable. */
+  name: string;
+  /** Optional CSS hex color (`#RRGGBB`). Clients fall back to a default palette when omitted. */
+  color?: string;
+  /** Display order; server keeps values contiguous `0..groups.length - 1` after every reorder. */
+  order: number;
+}
+
+/** Shape of the on-disk groups file at `<cwd>/openspec/groups/groups.json`.
+ *  Single combined file for groups + assignments — one read, one write, atomic.
+ *  See change: add-openspec-change-grouping. */
+export interface OpenSpecGroupsFile {
+  schemaVersion: number;
+  groups: OpenSpecGroup[];
+  /** `changeName` → `groupId`. Unassigned changes have no entry. */
+  assignments: Record<string, string>;
 }
 
 /** Lifecycle state of an OpenSpec change, derived from artifacts + task status */
@@ -425,6 +459,12 @@ export function deriveChangeState(change: OpenSpecChange): ChangeState {
 
 /** OpenSpec data for a session's project */
 export interface OpenSpecData {
+  /**
+   * `openspec list` returned authoritative data for this cwd. Requires both
+   * `<cwd>/openspec/` AND `<cwd>/openspec/changes/` to exist AND the CLI to
+   * succeed. Does NOT distinguish "openspec project, no changes yet" from
+   * "truly not an openspec project" — see `hasOpenspecDir` for that.
+   */
   initialized: boolean;
   changes: OpenSpecChange[];
   /**
@@ -440,6 +480,21 @@ export interface OpenSpecData {
    * See change: fix-cold-boot-openspec-protocol.
    */
   pending?: boolean;
+  /**
+   * Whether `<cwd>/openspec/` directory exists. Strictly weaker than
+   * `initialized`: this can be `true` while `initialized` is `false` when
+   * the project is OpenSpec-initialized (`openspec init` was run) but
+   * `openspec/changes/` doesn't exist yet (no proposals authored). In that
+   * case `openspec list` errors out and `initialized` stays `false`, but
+   * the session card should still show the OPENSPEC subcard as an
+   * init/attach affordance.
+   *
+   * Optional for backwards compatibility — absence means "unknown, fall
+   * back to `initialized || pending`" on the client side.
+   *
+   * See change: auto-hide-empty-session-subcards.
+   */
+  hasOpenspecDir?: boolean;
 }
 
 /** OpenSpec workflow phase detected from tool calls */

package/packages/shared/src/__tests__/resolve-jiti.test.ts

@@ -1,184 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  buildJitiRegisterUrl,
-  resolveJitiImport,
-  pickJitiRegisterUrl,
-  pickJitiFromAnchor,
-  JITI_PACKAGES,
-} from "../resolve-jiti.js";
-
-describe("buildJitiRegisterUrl", () => {
-  // Pure function: given a jiti package.json path, return the file:// URL of
-  // its register hook. The URL contract is the critical invariant — Node's
-  // --import on Windows rejects raw drive-letter paths (parses "C:" as a
-  // URL scheme). See change: fix-windows-server-parity.
-
-  it("returns a file:// URL", () => {
-    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
-    expect(url.startsWith("file://")).toBe(true);
-  });
-
-  it("URL is parseable by new URL() without throwing", () => {
-    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
-    expect(() => new URL(url)).not.toThrow();
-  });
-
-  it("points at lib/jiti-register.mjs under the package dir", () => {
-    const url = buildJitiRegisterUrl("/usr/lib/node_modules/@mariozechner/jiti/package.json");
-    expect(url.endsWith("/lib/jiti-register.mjs")).toBe(true);
-  });
-
-  it("handles Windows drive-letter paths (regression for ERR_UNSUPPORTED_ESM_URL_SCHEME)", () => {
-    // This is the exact shape that crashed pre-fix: a raw path with a
-    // drive letter was passed to `node --import` and Node parsed "B:" as
-    // a URL scheme. A file:// URL sidesteps the parser entirely.
-    const url = buildJitiRegisterUrl("B:\\Dev\\Nodejs\\global\\node_modules\\@mariozechner\\jiti\\package.json");
-    expect(url.startsWith("file:///")).toBe(true);
-    expect(() => new URL(url)).not.toThrow();
-    expect(new URL(url).protocol).toBe("file:");
-    // The drive letter survives as part of the pathname, not as a protocol
-    expect(url.toLowerCase()).toContain("/b:/");
-    expect(url.endsWith("/lib/jiti-register.mjs")).toBe(true);
-  });
-
-});
-
-describe("resolveJitiImport", () => {
-  // Integration-lite: behaviour depends on what's resolvable from
-  // process.argv[1] (the vitest runner). Two valid outcomes:
-  //   (a) vitest's own transitive `jiti` dep resolves → returns a URL.
-  //   (b) nothing resolves → throws the documented error.
-  // The URL-contract behaviour is covered by buildJitiRegisterUrl above
-  // and the lookup-order behaviour by pickJitiRegisterUrl below. This
-  // describe block exercises only the runtime-anchor branch.
-
-  it("either returns a file:// URL or throws the documented error", () => {
-    let result: string | undefined;
-    let err: Error | undefined;
-    try {
-      result = resolveJitiImport();
-    } catch (e) {
-      err = e as Error;
-    }
-    if (result !== undefined) {
-      expect(result.startsWith("file://")).toBe(true);
-      expect(result.endsWith("/lib/jiti-register.mjs")).toBe(true);
-    } else {
-      expect(err).toBeDefined();
-      expect(err!.message).toContain("Cannot find pi's TypeScript loader");
-      expect(err!.message).toContain("pi-coding-agent");
-    }
-  });
-});
-
-describe("JITI_PACKAGES contract", () => {
-  // The lookup-order contract: upstream first, legacy fork as fallback.
-  // Pinned so a future contributor doesn't accidentally re-order and
-  // silently change resolution priority for users mid-migration.
-  // See change: pi-fork migration to @earendil-works (drops @oh-my-pi).
-  it("contains the supported provider names in lookup order", () => {
-    expect(JITI_PACKAGES).toEqual(["jiti", "@mariozechner/jiti"]);
-  });
-});
-
-describe("pickJitiRegisterUrl (test seam)", () => {
-  // Mock a Node-style resolver. Returns a path when the spec matches
-  // a configured "installed" package; throws like Node's resolve() does
-  // for unfound modules.
-  function makeResolver(installed: Record<string, string>) {
-    return (spec: string): string => {
-      if (spec in installed) return installed[spec];
-      throw new Error(`Cannot find module '${spec}'`);
-    };
-  }
-
-  it("returns @mariozechner/jiti's URL when only the legacy fork is installed", () => {
-    const resolver = makeResolver({
-      "@mariozechner/jiti/package.json": "/r/node_modules/@mariozechner/jiti/package.json",
-    });
-    const url = pickJitiRegisterUrl(resolver);
-    expect(url).not.toBeNull();
-    expect(url!).toContain("@mariozechner/jiti");
-    expect(url!.endsWith("/lib/jiti-register.mjs")).toBe(true);
-  });
-
-  it("returns upstream jiti's URL when only upstream is installed (pi 0.73.1+)", () => {
-    const resolver = makeResolver({
-      "jiti/package.json": "/r/node_modules/jiti/package.json",
-    });
-    const url = pickJitiRegisterUrl(resolver);
-    expect(url).not.toBeNull();
-    // Match `/jiti/lib/...` but NOT `/@mariozechner/jiti/lib/...`
-    expect(url!).toMatch(/\/jiti\/lib\/jiti-register\.mjs$/);
-    expect(url!).not.toContain("@mariozechner");
-    expect(url!).not.toContain("@oh-my-pi");
-  });
-
-  it("prefers upstream jiti when BOTH upstream and legacy fork are present", () => {
-    const calls: string[] = [];
-    const resolver = (spec: string): string => {
-      calls.push(spec);
-      if (
-        spec === "@mariozechner/jiti/package.json" ||
-        spec === "jiti/package.json"
-      ) {
-        return `/r/node_modules/${spec}`;
-      }
-      throw new Error("nope");
-    };
-    const url = pickJitiRegisterUrl(resolver);
-    // Match `/jiti/lib/...` but NOT `/@mariozechner/jiti/lib/...`
-    expect(url!).toMatch(/\/jiti\/lib\/jiti-register\.mjs$/);
-    expect(url!).not.toContain("@mariozechner");
-    // Crucially: the resolver was NOT asked for the legacy fork because
-    // upstream won first.
-    expect(calls).toEqual(["jiti/package.json"]);
-  });
-
-  it("returns null when no provider resolves", () => {
-    const resolver = makeResolver({});
-    expect(pickJitiRegisterUrl(resolver)).toBeNull();
-  });
-});
-
-describe("pickJitiFromAnchor (test seam)", () => {
-  function makeResolver(installed: Record<string, string>) {
-    return (spec: string): string => {
-      if (spec in installed) return installed[spec];
-      throw new Error(`Cannot find module '${spec}'`);
-    };
-  }
-
-  it("returns upstream jiti's URL when only upstream is on the anchor's chain", () => {
-    const resolver = makeResolver({
-      "jiti/package.json": "/anchor/node_modules/jiti/package.json",
-    });
-    const pathExists = (p: string): boolean =>
-      p === "/anchor/node_modules/jiti/lib/jiti-register.mjs";
-    const url = pickJitiFromAnchor(resolver, pathExists);
-    expect(url).not.toBeNull();
-    expect(url!).toMatch(/\/jiti\/lib\/jiti-register\.mjs$/);
-  });
-
-  it("skips a provider whose register file does not exist on disk", () => {
-    // Resolver finds package.json but jiti-register.mjs is missing
-    // (corrupt install). Expect skip-to-next, ultimately null.
-    const resolver = makeResolver({
-      "@mariozechner/jiti/package.json":
-        "/anchor/node_modules/@mariozechner/jiti/package.json",
-    });
-    const pathExists = (): boolean => false;
-    expect(pickJitiFromAnchor(resolver, pathExists)).toBeNull();
-  });
-
-  it("returns null when nothing resolves", () => {
-    expect(
-      pickJitiFromAnchor(
-        () => {
-          throw new Error("nope");
-        },
-        () => true,
-      ),
-    ).toBeNull();
-  });
-});

package/packages/shared/src/resolve-jiti.ts

@@ -1,155 +0,0 @@
-/**
- * Resolve the jiti register hook from pi's process context.
- *
- * The bridge extension runs inside pi's Node.js process. process.argv[1]
- * points to pi's CLI entry (e.g., pi-coding-agent/dist/cli.js). Since
- * jiti is a dependency of pi-coding-agent, createRequire(process.argv[1])
- * can resolve it directly.
- *
- * Supported jiti providers, in lookup order:
- *   1. `@mariozechner/jiti` — legacy fork shipped with pi ≤ 0.73.0.
- *   2. `@oh-my-pi/jiti`     — fork shipped with `@oh-my-pi/pi-coding-agent`.
- *   3. `jiti`               — upstream package. Pi 0.73.1+ dropped the
- *                              fork in favour of upstream jiti 2.7,
- *                              which ships the same `lib/jiti-register.mjs`
- *                              layout the helpers below assume.
- *
- * Forks are tried first to preserve behaviour for users on older pi
- * versions; upstream is the fallthrough for pi 0.73.1+. See change:
- * support-upstream-jiti-resolution.
- */
-
-import { createRequire } from "node:module";
-import { existsSync, realpathSync } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-export const JITI_PACKAGES = [
-  // @earendil-works/pi-coding-agent depends on plain `jiti`. Try the
-  // bare name first; fall back to the legacy namespaced fork.
-  "jiti",
-  "@mariozechner/jiti",
-];
-
-/**
- * Pure helper: given a jiti package.json path, return the file:// URL of
- * its register hook. Exported for testing — no I/O.
- *
- * Returns a file:// URL (not a raw path) because Node >= 20 on Windows
- * rejects raw absolute paths with a drive letter for --import (parses
- * "C:" / "B:" as a URL scheme → ERR_UNSUPPORTED_ESM_URL_SCHEME). file://
- * URLs are accepted on every OS.
- * See change: fix-windows-server-parity.
- */
-export function buildJitiRegisterUrl(pkgJsonPath: string): string {
-  // Detect Windows-style input (drive letter + backslash) regardless of
-  // host OS, so unit tests can exercise the Windows path contract on macOS/Linux.
-  // Production behaviour is unchanged because the host-OS `path`/`pathToFileURL`
-  // match the input style automatically.
-  const isWindowsStyle = /^[A-Za-z]:[\\/]/.test(pkgJsonPath);
-  if (isWindowsStyle) {
-    // Manually build file:///C:/path/lib/jiti-register.mjs — pathToFileURL on
-    // POSIX hosts URL-encodes backslashes rather than treating them as
-    // separators. Do the join with path.win32 and format the URL ourselves.
-    const registerPath = path.win32.join(path.win32.dirname(pkgJsonPath), "lib", "jiti-register.mjs");
-    return `file:///${registerPath.replace(/\\/g, "/")}`;
-  }
-  const registerPath = path.join(path.dirname(pkgJsonPath), "lib", "jiti-register.mjs");
-  return pathToFileURL(registerPath).href;
-}
-
-/**
- * Test seam: a function that takes a package specifier (e.g.
- * `"jiti/package.json"`) and returns the resolved path. Production
- * supplies `createRequire(realpath(process.argv[1])).resolve`; tests
- * supply a stub.
- */
-export type JitiResolver = (specifier: string) => string;
-
-/**
- * Internal: walk the JITI_PACKAGES list using the given resolver and
- * return the first hit's register URL. Pure function once the
- * resolver is supplied. Returns null when no provider resolves.
- */
-export function pickJitiRegisterUrl(resolver: JitiResolver): string | null {
-  for (const jiti of JITI_PACKAGES) {
-    try {
-      const pkgJson = resolver(`${jiti}/package.json`);
-      return buildJitiRegisterUrl(pkgJson);
-    } catch { /* next */ }
-  }
-  return null;
-}
-
-/**
- * Returns jiti's register hook as a file:// URL suitable for `node --import`.
- * Uses process.argv[1] (pi's entry point) to anchor module resolution.
- *
- * The return value is ALWAYS a file:// URL (never a raw path). See
- * buildJitiRegisterUrl for the URL contract rationale.
- */
-export function resolveJitiImport(): string {
-  const anchor = process.argv[1];
-  if (anchor) {
-    try {
-      // Resolve symlinks — process.argv[1] may be a symlink (e.g., bin/pi → dist/cli.js)
-      const resolved = realpathSync(anchor);
-      const req = createRequire(resolved);
-      const url = pickJitiRegisterUrl((spec) => req.resolve(spec));
-      if (url) return url;
-    } catch { /* fall through */ }
-  }
-
-  throw new Error(
-    "Cannot find pi's TypeScript loader (jiti). " +
-    "Is @earendil-works/pi-coding-agent or @mariozechner/pi-coding-agent installed?"
-  );
-}
-
-/**
- * Resolve jiti's register hook from an arbitrary anchor path (e.g. a
- * pi-coding-agent package.json in a managed install, or a pi binary on
- * the system PATH). Returns a file:// URL or null if jiti cannot be
- * resolved from the anchor.
- *
- * This is the Electron/managed-install variant of `resolveJitiImport`
- * — the difference is the caller supplies the anchor explicitly
- * instead of using `process.argv[1]`. Consolidates what used to be a
- * duplicate `resolveJitiFromAnchor` in
- * `packages/electron/src/lib/server-lifecycle.ts`.
- * See change: consolidate-platform-handlers.
- */
-export function resolveJitiFromAnchor(anchorPath: string): string | null {
-  if (!existsSync(anchorPath)) return null;
-  try {
-    const req = createRequire(anchorPath);
-    for (const jiti of JITI_PACKAGES) {
-      try {
-        const pkgJson = req.resolve(`${jiti}/package.json`);
-        const registerPath = path.join(path.dirname(pkgJson), "lib", "jiti-register.mjs");
-        if (existsSync(registerPath)) return pathToFileURL(registerPath).href;
-      } catch { /* next */ }
-    }
-  } catch { /* ignore */ }
-  return null;
-}
-
-/**
- * Test seam for `resolveJitiFromAnchor`. Pure function: given a resolver
- * and a `pathExists` predicate, walk JITI_PACKAGES and return the first
- * hit's register URL. Production wires `createRequire(anchor).resolve`
- * and `existsSync`; tests inject stubs.
- */
-export function pickJitiFromAnchor(
-  resolver: JitiResolver,
-  pathExists: (p: string) => boolean,
-): string | null {
-  for (const jiti of JITI_PACKAGES) {
-    try {
-      const pkgJson = resolver(`${jiti}/package.json`);
-      const registerPath = path.join(path.dirname(pkgJson), "lib", "jiti-register.mjs");
-      if (pathExists(registerPath)) return pathToFileURL(registerPath).href;
-    } catch { /* next */ }
-  }
-  return null;
-}