@signalridge/pi-welcome 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 1.3.0
+### Minor Changes
+
+- 8488246: Put the inventory back, and take the wordmark off.
+  
+  With `quietStartup` on, Pi's `[Context]`/`[Skills]`/`[Prompts]`/`[Themes]`/
+  `[Extensions]` sections are gone and nothing brings them back — `/reload` re-runs
+  the same suppressed listing. The card had replaced all of that with three
+  counts, which is strictly less than what the session used to show. It now names
+  them instead, eight per row with a `+N` tail: context files, skills, prompts,
+  extensions, themes, and the tool count.
+  
+  Skills and prompts now come from `getCommands()` rather than `loadSkills()`. An
+  extension may contribute skill paths through `resources_discover`, which is
+  where most of them come from in practice, and the standalone loader cannot see
+  those — measured on a real session it returned zero skills while Pi was showing
+  dozens. Extensions and themes are read from the same settings files and
+  directories Pi reads.
+  
+  The ridgeline mark, the `SIGNALRIDGE / PI` wordmark, and the tagline are gone.
+  The card exists to say what this session is, and a brand line says nothing a
+  returning user does not already know; the key hints lead instead, since with
+  `quietStartup` on they appear nowhere else. The Pi version returns to a row of
+  its own.
+
 ## 1.0.0
 ### Major Changes
 

package/README.md

@@ -1,31 +1,35 @@
 # pi-welcome
 
 TUI-only Signalridge startup card: one rounded panel with the current
-repository, model, context budget, key hints, and a count of what Pi loaded. It
+repository, model, context budget, key hints, and the inventory of what Pi loaded. It
 uses the active Pi theme, persists a bounded custom entry so a resumed session
 redraws it, and collapses to a width-safe compact summary on narrow terminals.
 
 ```
-╭──────────────────────────────────────────────────────────────────────╮
-│                                                                      │
-│  ╭─╮  SIGNALRIDGE / PI                                       v0.84.1 │
-│  ╰─╯  A focused coding workspace                                     │
-│                                                                      │
-│  Ctrl+C interrupt · / commands · ! bash · Ctrl+L clear               │
-│                                                                      │
-│  Directory: ~/ghq/github.com/signalridge/pi-extensions               │
-│  Branch:    main [+392 -202]                                         │
-│  Session:   (new)                                                    │
-│  Model:     openai-codex / gpt-5.6-luna · thinking max               │
-│  Budget:    400K · compacts at 270K                                  │
-│                                                                      │
-│  Context:   AGENTS.md · CLAUDE.md                                    │
-│  Loaded:    61 skills · 12 prompts · 9 commands from extensions      │
-│  Tools:     18 active of 42                                          │
-│                                                                      │
-╰──────────────────────────────────────────────────────────────────────╯
+╭─────────────────────────────────────────────────────────────────────────╮
+│                                                                         │
+│  Ctrl+C interrupt · / commands · ! bash · Ctrl+L clear                  │
+│                                                                         │
+│  Directory:  ~/ghq/github.com/signalridge/pi-extensions                 │
+│  Branch:     main [+392 -202]                                           │
+│  Session:    (new)                                                      │
+│  Model:      openai-codex / gpt-5.6-luna · thinking max                 │
+│  Budget:     400K · compacts at 270K                                    │
+│  Version:    0.84.1                                                     │
+│                                                                         │
+│  Context:    AGENTS.md                                                  │
+│  Skills:     commit, dev-preferences, toolbelt, write-tui +12           │
+│  Prompts:    /plan, /review, /ship +4                                   │
+│  Extensions: btw, code-actions, goal, gpt-fast, statusline +18          │
+│  Themes:     catppuccin-mocha, signalridge-ridgeline +2                 │
+│  Tools:      18 active of 42                                            │
+│                                                                         │
+╰─────────────────────────────────────────────────────────────────────────╯
 ```
 
+No logo and no wordmark: the card exists to say what this session is, and a
+brand line says nothing a returning user does not already know.
+
 ## Turn on `quietStartup`
 
 The card is designed to be the whole opening screen. Pi's own startup is a
@@ -45,16 +49,24 @@ actionable is hidden.
 Leaving `quietStartup: false` is supported and changes nothing about the card;
 Pi simply prints its own block above it again.
 
-## What the counts come from
+## Where the inventory comes from
+
+With `quietStartup` on, Pi's `[Context]`/`[Skills]`/`[Prompts]`/`[Themes]`/
+`[Extensions]` sections are gone and nothing brings them back — `/reload` re-runs
+the same suppressed listing — so this card is the only place they appear. It
+names them rather than counting them, capped at eight per row with a `+N` tail.
+
+Skills and prompts come from `getCommands()`, **not** from `loadSkills()`. An
+extension may contribute skill paths through `resources_discover`, which is
+where most of them come from in practice, and the standalone loader cannot see
+those: on a session showing dozens of skills it returns zero. `getCommands()`
+reports what Pi actually registered.
 
-`Context`, `Loaded`, and `Tools` are counted through Pi's public API only:
-`loadProjectContextFiles` and `loadSkills` are pure filesystem reads, and
-`getCommands()` / `getAllTools()` report what is actually registered. Pi renders
-its full `[Skills]` / `[Prompts]` / `[Extensions]` listing from a resource
-loader it does not expose read-only, and the only way to obtain a second one is
-to construct it — whose `reload()` re-executes every extension factory and would
-duplicate tools, listeners, timers, and child processes. So the card reports
-counts it can derive honestly and leaves out what it cannot.
+Extensions and themes are read from the same settings files and directories Pi
+reads. Context files come from `loadProjectContextFiles`, and tool counts from
+`getAllTools()` / `getActiveTools()`. Nothing here constructs a second resource
+loader: its `reload()` re-executes every extension factory and would duplicate
+tools, listeners, timers, and child processes.
 
 ## Untrusted text
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalridge/pi-welcome",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Startup resource and repository summary card for Pi.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -20,7 +20,7 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 
@@ -30,7 +30,6 @@ import {
   getAgentDir,
   keyText,
   loadProjectContextFiles,
-  loadSkills,
   type Theme,
   VERSION,
 } from "@earendil-works/pi-coding-agent";
@@ -38,11 +37,6 @@ import { type Component, truncateToWidth, visibleWidth, wrapTextWithAnsi } from
 
 const ENTRY_TYPE = "welcome-card";
 
-/** A small original ridgeline mark; no private-use or font-specific glyphs. */
-const LOGO = ["╭─╮", "╰─╯"] as const;
-const BRAND = "SIGNALRIDGE / PI";
-const SUBTITLE = "A focused coding workspace";
-
 /** Columns of padding inside the card. */
 const PAD = 2;
 
@@ -52,8 +46,16 @@ const MIN_WIDTH = 20;
 /** Sentinel row rendered as a blank line, separating the card's groups. */
 const GAP: [string, string] = ["", ""];
 
-/** Most context-file names to spell out before collapsing the rest into a count. */
-const MAX_CONTEXT_NAMES = 3;
+/**
+ * Names to spell out in a resource row before collapsing the rest into `+N`.
+ *
+ * Pi's own listing prints every name and lets it wrap; with `quietStartup` on
+ * that listing is gone and this card is the only place the inventory appears,
+ * so it errs toward showing names rather than a bare count. Eight is what fits
+ * on one line at a normal width without turning the card into the wall of text
+ * the merge was meant to remove.
+ */
+const MAX_NAMES = 8;
 
 interface WelcomeData {
   rows: [string, string][];
@@ -128,8 +130,19 @@ function formatTokens(n: number): string {
   return String(n);
 }
 
-function plural(count: number, noun: string): string {
-  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+/** `a, b, c +58` — the first few names, then how many were left out. */
+function nameList(names: readonly string[], max = MAX_NAMES): string | undefined {
+  if (names.length === 0) return undefined;
+  const shown = names.slice(0, max).join(", ");
+  const rest = names.length - max;
+  return rest > 0 ? `${shown} +${rest}` : shown;
+}
+
+/** Sorted, de-duplicated, and free of empties — every row is built from this. */
+function tidy(names: Iterable<string>): string[] {
+  return [...new Set([...names].map((name) => name.trim()).filter((name) => name.length > 0))].sort((a, b) =>
+    a.localeCompare(b),
+  );
 }
 
 /**
@@ -172,59 +185,94 @@ export function collectHints(): string[] {
 }
 
 /**
- * What pi loaded for this session, as counts rather than a listing.
+ * Extension names, as Pi's own `[Extensions]` section lists them.
  *
- * Pi renders the full `[Skills]`/`[Prompts]`/`[Extensions]` listing itself and
- * exposes no read-only API for it — the loader that holds it can only be
- * obtained by constructing a second one, whose `reload()` executes every
- * extension factory again and would duplicate tools, listeners, timers, and
- * child processes. So this counts through the public surfaces only:
- * `loadSkills` and `loadProjectContextFiles` are pure filesystem reads that
- * execute nothing, and `getCommands()` reports what is actually registered.
- * Anything not derivable that way is left off rather than guessed at.
+ * Read from the same two settings files Pi reads, plus the extension
+ * directories it scans. Pi labels a package-sourced extension by its package
+ * name and a file-sourced one by its path, so the scope and the `pi-` prefix
+ * come off to leave the part that identifies it.
+ */
+function collectExtensionNames(cwd: string): string[] {
+  const names: string[] = [];
+  for (const settingsFile of [join(getAgentDir(), "settings.json"), join(cwd, ".pi", "settings.json")]) {
+    try {
+      const packages = JSON.parse(readFileSync(settingsFile, "utf8"))?.packages;
+      if (!Array.isArray(packages)) continue;
+      for (const entry of packages) {
+        const source = typeof entry === "string" ? entry : entry?.source;
+        if (typeof source !== "string") continue;
+        const spec = source.replace(/^npm:/u, "");
+        // `@scope/pi-name@1.2.3` and `./local/path` both reduce to a bare name.
+        const bare = (spec.startsWith("@") ? (spec.split("/")[1] ?? spec) : basename(spec)).replace(/@.*$/u, "");
+        names.push(bare.replace(/^pi-/u, ""));
+      }
+    } catch {}
+  }
+  for (const directory of [join(getAgentDir(), "extensions"), join(cwd, ".pi", "extensions")]) {
+    try {
+      for (const entry of readdirSync(directory)) {
+        names.push(entry.replace(/\.[cm]?[jt]s$/u, "").replace(/^pi-/u, ""));
+      }
+    } catch {}
+  }
+  return tidy(names);
+}
+
+/** Custom theme names, as Pi's own `[Themes]` section lists them. */
+function collectThemeNames(): string[] {
+  try {
+    return tidy(
+      readdirSync(join(getAgentDir(), "themes"))
+        .filter((entry) => entry.endsWith(".json"))
+        .map((entry) => entry.replace(/\.json$/u, "")),
+    );
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * What pi loaded for this session, by name — the inventory its own
+ * `[Context]`/`[Skills]`/`[Prompts]`/`[Themes]`/`[Extensions]` sections print.
+ *
+ * With `quietStartup` on those sections are gone and nothing brings them back
+ * (`/reload` re-runs the same suppressed listing), so this card is the only
+ * place the inventory appears and it names things rather than counting them.
+ *
+ * Skills and prompts come from `getCommands()`, not from `loadSkills()`: an
+ * extension may contribute skill paths through `resources_discover`, which is
+ * where most of them come from here, and the standalone loader cannot see those
+ * — it reports zero on a session showing dozens. `getCommands()` reports what
+ * Pi actually registered, which is the honest answer to "what loaded".
  */
 export function collectResources(pi: ExtensionAPI, cwd: string): [string, string][] {
   const rows: [string, string][] = [];
+  const push = (label: string, value: string | undefined) => {
+    if (value) rows.push([label, value]);
+  };
 
-  const contextNames = (() => {
-    try {
-      const files = loadProjectContextFiles({ cwd, agentDir: getAgentDir() });
-      // Several scopes can contribute the same filename (a project AGENTS.md
-      // and a global one); the card is naming kinds of context, not paths.
-      const names = [...new Set(files.map((file) => basename(file.path)))];
-      if (names.length === 0) return undefined;
-      const shown = names.slice(0, MAX_CONTEXT_NAMES).join(" · ");
-      const rest = names.length - MAX_CONTEXT_NAMES;
-      return rest > 0 ? `${shown} · +${rest}` : shown;
-    } catch {
-      return undefined;
-    }
-  })();
-  if (contextNames) rows.push(["Context", contextNames]);
-
-  const loaded: string[] = [];
   try {
-    const { skills } = loadSkills({
-      cwd,
-      agentDir: getAgentDir(),
-      skillPaths: [],
-      includeDefaults: true,
-    });
-    if (skills.length > 0) loaded.push(plural(skills.length, "skill"));
+    const files = loadProjectContextFiles({ cwd, agentDir: getAgentDir() });
+    // Several scopes can contribute the same filename (a project AGENTS.md and
+    // a global one); the card names kinds of context, not paths.
+    push("Context", nameList(tidy(files.map((file) => basename(file.path)))));
   } catch {}
+
   try {
     const commands = pi.getCommands?.() ?? [];
-    const prompts = commands.filter((command) => command.source === "prompt").length;
-    const extensionCommands = commands.filter((command) => command.source === "extension").length;
-    if (prompts > 0) loaded.push(plural(prompts, "prompt"));
-    if (extensionCommands > 0) loaded.push(`${plural(extensionCommands, "command")} from extensions`);
+    const named = (source: string, prefix = "") =>
+      tidy(commands.filter((command) => command.source === source).map((command) => `${prefix}${command.name}`));
+    push("Skills", nameList(named("skill")));
+    push("Prompts", nameList(named("prompt", "/")));
   } catch {}
-  if (loaded.length > 0) rows.push(["Loaded", loaded.join(" · ")]);
+
+  push("Extensions", nameList(collectExtensionNames(cwd)));
+  push("Themes", nameList(collectThemeNames()));
 
   try {
     const all = pi.getAllTools?.() ?? [];
     const active = pi.getActiveTools?.() ?? [];
-    if (all.length) rows.push(["Tools", `${active.length} active of ${all.length}`]);
+    if (all.length) push("Tools", `${active.length} active of ${all.length}`);
   } catch {}
 
   return rows;
@@ -271,6 +319,8 @@ function collect(pi: ExtensionAPI, ctx: ExtensionContext): WelcomeData {
     }
   }
 
+  push("Version", VERSION);
+
   // GAP is the sentinel for a blank row: session facts above, what pi loaded
   // below, so the card reads as two groups rather than one wall.
   const resources = collectResources(pi, ctx.cwd);
@@ -356,7 +406,6 @@ export class WelcomeCard implements Component {
   private renderCompact(width: number): string[] {
     const t = this.theme;
     const lines = [
-      t.bold(t.fg("accent", "sr / pi")),
       t.fg("muted", this.hints.length > 0 ? (this.hints[0] ?? "ready") : "ready"),
       ...this.rows.map(([label, value]) =>
         label === GAP[0] && value === GAP[1] ? "" : `${t.fg("dim", `${label}:`)} ${t.fg("text", value)}`,
@@ -376,30 +425,18 @@ export class WelcomeCard implements Component {
     const blank = () => line("");
     const pad = " ".repeat(PAD);
     const body: string[] = [blank()];
-    const logoWidth = Math.max(...LOGO.map(visibleWidth));
-
-    // The version rides the brand line rather than taking a row of its own: it
-    // is the one fact nobody scans for, and the row it used to occupy sat at
-    // the bottom where the eye lands last.
-    const version = t.fg("dim", `v${VERSION}`);
-    const brandRoom = Math.max(0, inner - PAD - logoWidth - PAD - PAD - visibleWidth(version));
-    const brand = t.bold(t.fg("text", BRAND));
-    const brandLine = brand + " ".repeat(Math.max(1, brandRoom - visibleWidth(BRAND) + 1)) + version;
-
-    body.push(
-      line(pad + t.fg("accent", LOGO[0].padEnd(logoWidth)) + pad + brandLine),
-      line(pad + t.fg("accent", LOGO[1].padEnd(logoWidth)) + pad + t.fg("muted", SUBTITLE)),
-    );
 
+    // No mark and no wordmark. The card exists to say what this session is, and
+    // a brand line says nothing a returning user does not already know. The
+    // hints lead instead: with `quietStartup` on this is the only place they
+    // appear, and they are what a new session actually needs.
     const hintLine = fitHints(this.hints, Math.max(1, inner - PAD * 2));
     if (hintLine) {
       // The whole line is dimmed rather than highlighting each key: this is
       // orientation, not a control the user is meant to look at.
-      body.push(blank(), line(pad + t.fg("dim", hintLine)));
+      body.push(line(pad + t.fg("dim", hintLine)), blank());
     }
 
-    body.push(blank());
-
     const labelWidth = this.rows.length ? Math.max(...this.rows.map(([label]) => visibleWidth(label))) + 2 : 0;
     for (const [label, value] of this.rows) {
       if (label === GAP[0] && value === GAP[1]) {