@gavin-hu/my-pi-agent 0.15.1 → 0.17.0

package/extensions/bytefly/panel/commands.ts

@@ -1,9 +1,10 @@
 /**
- * The `/bytefly` surface: one command, `/bytefly [doctor] [settings] [update] [extension] [refresh]`.
+ * The `/bytefly` surface: one command, `/bytefly [doctor] [settings] [skills] [update] [extension] [refresh]`.
  *
- * Without `doctor` it opens the extension screen: the dock in `tui`, the
+ * Without a section word it opens the extension screen: the dock in `tui`, the
  * grouped listing elsewhere. `settings` opens the Settings section, or prints
- * its grouped listing outside `tui` without resolving packages. `update`
+ * its grouped listing outside `tui` without resolving packages. `skills` opens
+ * the Skills section and lists the resolved skills in text modes. `update`
  * re-runs the published-version check and reports what it found, which is the
  * one place a request is made on demand. With `doctor` it produces the doctor
  * report — the same text `run_doctor` returns — for the whole set or one named
@@ -23,12 +24,13 @@ import { formatExtension, formatReport, hasProblems } from "../doctor/format.ts"
 import type { DoctorRuntime } from "../doctor/runtime.ts";
 import { updateOutcomeText } from "../update/format.ts";
 import type { UpdateHandle } from "../update/register.ts";
-import { createSettingsStores, discoverExtensions, type DiscoveryDeps } from "../picker/discovery.ts";
-import { createExtensionsPickerRuntime, type ExtensionsPickerRuntime } from "../picker/runtime.ts";
+import { createSettingsStores, discoverResources, type DiscoveryDeps } from "../picker/discovery.ts";
+import { createPickerRuntime, type PickerRuntime } from "../picker/runtime.ts";
 import type { Discovery } from "../picker/types.ts";
-import { formatListing, formatSettingsListing } from "./format.ts";
-import { buildPanelModel, extensionName } from "./join.ts";
+import { formatListing, formatSettingsListing, SKILL_NOUN } from "./format.ts";
+import { buildPanelModel, buildSkillModel, extensionName } from "./join.ts";
 import { createSettingsRuntime, type SettingsRuntime, type SettingsRuntimeDeps } from "./settings-runtime.ts";
+import { loadSkillIndex, resolvedSkillPaths, type SkillIndex } from "./skills.ts";
 import { shippedThemeNames } from "./themes.ts";
 import { PanelComponent } from "./tui.ts";
 import type { PanelSection } from "./types.ts";
@@ -43,6 +45,8 @@ export interface PanelCommandDeps {
 	discover?: (deps: DiscoveryDeps) => Promise<Discovery>;
 	/** The Settings runtime seam. */
 	settings?: (deps: SettingsRuntimeDeps) => SettingsRuntime;
+	/** The skill-metadata seam; `loadSkillIndex` unless a test supplies one. */
+	skills?: (paths: readonly string[], cwd: string, agentDir: string) => SkillIndex;
 }
 
 /**
@@ -52,19 +56,21 @@ export interface PanelCommandDeps {
  */
 function selectableNames(discovery: Discovery): Set<string> {
 	const names = new Set<string>(Object.keys(REQUIREMENTS));
-	for (const item of [...discovery.global, ...discovery.effective]) names.add(extensionName(item.path));
+	for (const item of [...discovery.extensions.global, ...discovery.extensions.effective]) {
+		names.add(extensionName(item.path));
+	}
 	return names;
 }
 
 /** The values a bare `/bytefly <tab>` offers, in screen order. */
-const FIRST_TOKENS = ["doctor", "settings", "update", ...Object.keys(REQUIREMENTS), "refresh"] as const;
+const FIRST_TOKENS = ["doctor", "settings", "skills", "update", ...Object.keys(REQUIREMENTS), "refresh"] as const;
 
 /**
  * Argument completions. The host replaces the whole argument text with the
  * returned `value`, so a second token returns the full `doctor <name>` or
- * `<name> refresh` argument rather than just the word. `/bytefly settings` and
- * `/bytefly update` take no name, and `refresh` is never followed by another
- * token.
+ * `<name> refresh` argument rather than just the word. `/bytefly settings`,
+ * `/bytefly skills`, and `/bytefly update` take no name, and `refresh` is never
+ * followed by another token.
  */
 function completions(prefix: string): Array<{ value: string; label: string }> | null {
 	const [first = "", second, ...rest] = prefix.trimStart().split(/\s+/);
@@ -73,7 +79,7 @@ function completions(prefix: string): Array<{ value: string; label: string }> |
 		const options = FIRST_TOKENS.filter((option) => option.startsWith(first));
 		return options.length > 0 ? options.map((option) => ({ value: `${option} `, label: option })) : null;
 	}
-	if (first === "settings" || first === "refresh" || first === "update") return null;
+	if (first === "settings" || first === "skills" || first === "refresh" || first === "update") return null;
 	const options = (first === "doctor" ? [...Object.keys(REQUIREMENTS), "refresh"] : ["refresh"]).filter((option) =>
 		option.startsWith(second),
 	);
@@ -94,7 +100,7 @@ interface PanelArgs {
 	refresh: boolean;
 }
 
-/** Parse `/bytefly [doctor] [settings] [update] [extension] [refresh]`; extra tokens are ignored. */
+/** Parse `/bytefly [doctor] [settings] [skills] [update] [extension] [refresh]`; extra tokens are ignored. */
 function parseArgs(args: string): PanelArgs {
 	const parts = args.trim().split(/\s+/).filter(Boolean);
 	const refresh = parts.includes("refresh");
@@ -104,6 +110,7 @@ function parseArgs(args: string): PanelArgs {
 	// beside it is accepted and ignored rather than refused.
 	if (rest[0] === "update") return { mode: "update", section: "extensions", refresh };
 	if (rest[0] === "settings") return { mode: "screen", section: "settings", name: rest[1], refresh };
+	if (rest[0] === "skills") return { mode: "screen", section: "skills", name: rest[1], refresh };
 	return { mode: "screen", section: "extensions", name: rest[0], refresh };
 }
 
@@ -115,14 +122,14 @@ function notifyExtension(
 	ctx: ExtensionCommandContext,
 	name: string,
 	reports: readonly ExtensionReport[],
-	runtime: ExtensionsPickerRuntime,
+	runtime: PickerRuntime,
 ): void {
 	const report = reports.find((entry) => entry.extension === name);
 	if (report) {
 		ctx.ui.notify(formatExtension(report), hasProblems([report]) ? "warning" : "info");
 		return;
 	}
-	const item = runtime.items().find((entry) => extensionName(entry.path) === name);
+	const item = runtime.items("extensions").find((entry) => extensionName(entry.path) === name);
 	ctx.ui.notify(
 		item
 			? `bytefly: ${sanitizeLine(item.path)} — no doctor report`
@@ -146,15 +153,16 @@ function settingsThemeNames(ctx: ExtensionCommandContext): string[] {
 
 /** Register the single `/bytefly` command. */
 export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
-	const discover = deps.discover ?? discoverExtensions;
+	const discover = deps.discover ?? discoverResources;
 	const makeSettings = deps.settings ?? createSettingsRuntime;
+	const loadSkills = deps.skills ?? loadSkillIndex;
 
 	const handler = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
 		const { mode, section, name, refresh } = parseArgs(args);
-		// `/bytefly settings` has no extension argument; a stray word is a typo, not
-		// a filter, so say so rather than ignoring it.
-		if (section === "settings" && name !== undefined) {
-			ctx.ui.notify(`bytefly: /bytefly settings takes no extension name (got "${sanitizeLine(name)}").`, "warning");
+		// Only the Extensions section takes an extension argument; a stray word is a
+		// typo, not a filter, so say so rather than ignoring it.
+		if (section !== "extensions" && name !== undefined) {
+			ctx.ui.notify(`bytefly: /bytefly ${section} takes no extension name (got "${sanitizeLine(name)}").`, "warning");
 			return;
 		}
 		const cwd = ctx.cwd ?? process.cwd();
@@ -195,7 +203,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		try {
 			discovery = await discover({ cwd, agentDir, trusted });
 		} catch (error) {
-			ctx.ui.notify(`Could not list extensions: ${error instanceof Error ? error.message : String(error)}`, "error");
+			ctx.ui.notify(`Could not list resources: ${error instanceof Error ? error.message : String(error)}`, "error");
 			return;
 		}
 
@@ -208,7 +216,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			onError: settingsNotice,
 		});
 
-		const runtime = createExtensionsPickerRuntime({
+		const runtime = createPickerRuntime({
 			discovery,
 			cwd,
 			agentDir,
@@ -222,6 +230,18 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			return;
 		}
 
+		// Skills outside `tui` print the same grouped listing, from the metadata Pi's
+		// loader reads; there is no report to probe for and no package to resolve.
+		if (section === "skills" && ctx.mode !== "tui") {
+			const index = loadSkills(resolvedSkillPaths(discovery), cwd, agentDir);
+			const model = buildSkillModel({ items: runtime.items("skills"), index, agentDir });
+			ctx.ui.notify(
+				formatListing(model, runtime.scope(), { noun: SKILL_NOUN, emptyLabel: "No skills found." }),
+				"info",
+			);
+			return;
+		}
+
 		// Text modes print the report, so they probe now. The dock screen opens on
 		// the session cache and probes on its first Extensions view instead, which
 		// keeps `/bytefly` and `/bytefly settings` instant.
@@ -243,7 +263,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 				ctx.ui.notify(formatReport(reports), hasProblems(reports) ? "warning" : "info");
 				return;
 			}
-			const model = buildPanelModel({ items: runtime.items(), reports, agentDir });
+			const model = buildPanelModel({ items: runtime.items("extensions"), reports, agentDir });
 			ctx.ui.notify(formatListing(model, runtime.scope()), "info");
 			return;
 		}
@@ -269,6 +289,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 					initialRefresh: refresh,
 					viewportRows: () => tui.terminal?.rows,
 					requestRender: () => tui.requestRender(),
+					skills: () => loadSkills(resolvedSkillPaths(discovery), cwd, agentDir),
 					refresh: async (force) => {
 						reports = await deps.doctor.probeAll({ refresh: force === true });
 					},
@@ -293,7 +314,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 
 	pi.registerCommand("bytefly", {
 		description:
-			"Open the bytefly control center: /bytefly [extension] [refresh] lists extensions, /bytefly settings opens settings; /bytefly doctor [extension] [refresh] prints the doctor report",
+			"Open the bytefly control center: /bytefly [extension] [refresh] lists extensions, /bytefly skills lists skills, /bytefly settings opens settings; /bytefly doctor [extension] [refresh] prints the doctor report",
 		getArgumentCompletions: completions,
 		handler,
 	});

package/extensions/bytefly/panel/format.ts

@@ -3,7 +3,7 @@
  *
  * Every mode other than `tui` gets the same facts the screen shows, as plain
  * text: a headline with the scope and the counts, then the picker's grouped
- * listing with a health suffix on each row. The Settings listing uses the same
+ * listing with a verdict suffix on each row. The Settings listing uses the same
  * headline and groups with `Label: Value` rows. A single named extension prints
  * its full findings instead. Nothing here touches the host, and every string
  * from a probe or a settings file is sanitized before it is printed.
@@ -18,7 +18,7 @@ import { sanitizeLine } from "../../../lib/format.ts";
 import { GLYPHS } from "../../../lib/tui/glyphs.ts";
 import type { TuiRole } from "../../../lib/tui/tokens.ts";
 import { reportSeverity, reportSummary, severityGlyphChar, severityRole } from "../doctor/format.ts";
-import { groupViews, type SettingView } from "./settings.ts";
+import type { SettingView } from "./settings.ts";
 import type { PanelModel, PanelRow, PanelSection } from "./types.ts";
 
 /** The settings scope the screen shows. */
@@ -32,17 +32,35 @@ export interface SummarySegment {
 
 /** Row and problem counts over a model. */
 interface PanelCounts {
-	extensions: number;
+	rows: number;
 	/** Rows switched off in settings (the picker's checkbox), not the env flag. */
 	off: number;
 	missing: number;
 	degraded: number;
 }
 
+/** How one row is counted in the headline, singular, plural, and abbreviated. */
+export interface CountNoun {
+	one: string;
+	many: string;
+	/** The form a narrow terminal uses. */
+	compact: string;
+}
+
+/** Extensions are the default noun; Skills pass their own. */
+export const EXTENSION_NOUN: CountNoun = { one: "extension", many: "extensions", compact: "ext" };
+
+/** The Skills section's noun: `4 skills`, and the same word when narrowed. */
+export const SKILL_NOUN: CountNoun = { one: "skill", many: "skills", compact: "skills" };
+
 /** Options for the plain-text headline and listing. */
 export interface PanelTextOptions {
 	/** Abbreviate counts (`15 ext · 3 off`) for a narrow terminal. */
 	compact?: boolean;
+	/** What one row is called; extensions by default. */
+	noun?: CountNoun;
+	/** What the listing says when it has no rows. */
+	emptyLabel?: string;
 }
 
 /** Options for the TUI headline, which can also name a narrowed extension. */
@@ -72,7 +90,7 @@ export function panelCounts(model: PanelModel): PanelCounts {
 		missing += report.findings.filter((finding) => finding.severity === "missing").length;
 		degraded += report.findings.filter((finding) => finding.severity === "degraded").length;
 	}
-	return { extensions: model.rows.length, off, missing, degraded };
+	return { rows: model.rows.length, off, missing, degraded };
 }
 
 /**
@@ -81,12 +99,13 @@ export function panelCounts(model: PanelModel): PanelCounts {
  */
 export function summarySegments(model: PanelModel, scope: PanelScope, options: SummaryOptions = {}): SummarySegment[] {
 	const counts = panelCounts(model);
+	const forms = options.noun ?? EXTENSION_NOUN;
 	const segments: SummarySegment[] = [{ text: scope === "global" ? "Global" : "Project", color: "accent" }];
 	if (options.filter !== undefined) {
 		segments.push({ text: `${options.filter} only`, color: "meta" });
 	} else {
-		const noun = options.compact ? "ext" : counts.extensions === 1 ? "extension" : "extensions";
-		segments.push({ text: `${counts.extensions} ${noun}`, color: "meta" });
+		const noun = options.compact ? forms.compact : counts.rows === 1 ? forms.one : forms.many;
+		segments.push({ text: `${counts.rows} ${noun}`, color: "meta" });
 		if (counts.off > 0) segments.push({ text: `${counts.off} off`, color: "meta" });
 	}
 	const problems: string[] = [];
@@ -98,15 +117,25 @@ export function summarySegments(model: PanelModel, scope: PanelScope, options: S
 	return segments;
 }
 
+/** The sections left to right, as the bar reads them. */
+export const SECTION_ORDER: readonly PanelSection[] = ["extensions", "skills", "settings"];
+
+/** One section's name in the bar. */
+const SECTION_LABELS: Record<PanelSection, string> = {
+	extensions: "Extensions",
+	skills: "Skills",
+	settings: "Settings",
+};
+
 /**
- * The section bar's two segments, in screen order. The active section takes the
- * accent and the other recedes, so the bar reads as a two-way switch.
+ * The section bar's segments, in screen order. The active section takes the
+ * accent and the others recede, so the bar reads as a left-to-right switch.
  */
 export function sectionSegments(active: PanelSection): SummarySegment[] {
-	return [
-		{ text: "Extensions", color: active === "extensions" ? "accent" : "faint" },
-		{ text: "Settings", color: active === "settings" ? "accent" : "faint" },
-	];
+	return SECTION_ORDER.map((section) => ({
+		text: SECTION_LABELS[section],
+		color: active === section ? "accent" : "faint",
+	}));
 }
 
 /** The Settings section's counts: the scope and how many rows it shows. */
@@ -125,15 +154,10 @@ export function formatSettingsHeadline(count: number): string {
 	return `bytefly: Settings · Global · ${count} settings`;
 }
 
-/** The grouped Settings listing for non-TUI modes. */
+/** The Settings listing for non-TUI modes, one row per line, in screen order. */
 export function formatSettingsListing(views: readonly SettingView[]): string {
 	const lines = [formatSettingsHeadline(views.length)];
-	for (const group of groupViews(views)) {
-		lines.push("", `${group.label} (${group.views.length})`);
-		for (const view of group.views) {
-			lines.push(`  ${sanitizeLine(view.label)}: ${sanitizeLine(view.valueLabel)}`);
-		}
-	}
+	for (const view of views) lines.push(`  ${sanitizeLine(view.label)}: ${sanitizeLine(view.valueLabel)}`);
 	return lines.join("\n");
 }
 
@@ -156,15 +180,21 @@ interface RowBadge {
 
 /**
  * The row's badge. Settings is the enablement axis the checkbox already shows,
- * so an off extension gets one verdict (`off`) instead of a health word that
+ * so an off row gets one verdict (`off`) instead of a health word that
  * contradicts it. `PI_DISABLED_EXTENSIONS` is a different axis, so it is named
- * rather than sharing the word: `env disabled`. The glyph marks what needs
+ * rather than sharing the word: `env disabled`. A skill has no probed report, so
+ * its own file supplies the verdict: `not loaded` when Pi refused it, `hidden`
+ * when it is reachable only through `/skill:<name>`. The glyph marks what needs
  * attention — a warning, a miss, a disable — so a row with nothing to report
  * carries no glyph at all, and the column reads as one shape instead of a
  * checkmark that comes and goes.
  */
 export function rowBadge(row: PanelRow): RowBadge {
 	if (row.item && !row.item.enabled) return { glyph: GLYPHS.disabled, role: "faint", text: "off" };
+	// A skill's verdict comes from its own file, not from a probed report: a file
+	// Pi refused is a warning, and one hidden from the model still loads by name.
+	if (row.skill?.problem !== undefined) return { glyph: GLYPHS.warn, role: "warn", text: "not loaded" };
+	if (row.skill?.modelHidden === true) return { role: "faint", text: "hidden" };
 	const report = row.report;
 	if (!report) return { role: "faint" };
 	if (!report.enabled) return { glyph: GLYPHS.disabled, role: "faint", text: "env disabled" };
@@ -190,7 +220,7 @@ export function formatRow(row: PanelRow): string {
 export function formatListing(model: PanelModel, scope: PanelScope, options: PanelTextOptions = {}): string {
 	const lines = [formatHeadline(model, scope, options)];
 	if (model.rows.length === 0) {
-		lines.push("", "No extensions found.");
+		lines.push("", options.emptyLabel ?? "No extensions found.");
 		return lines.join("\n");
 	}
 	for (const group of model.groups) {

package/extensions/bytefly/panel/join.ts

@@ -1,9 +1,10 @@
 /**
- * The merge behind the unified panel: one row per extension resource, joining
- * the picker's resolved items to the doctor's reports.
+ * The merge behind the unified panel: one row per resolved resource, joining the
+ * picker's items to whatever describes them — the doctor's report for an
+ * extension, the loaded `SKILL.md` metadata for a skill.
  *
- * The join key is the extension directory (`basename(dirname(path))`), not the
- * display name: a subfolder resource is shown as `web-access/index.ts` but its
+ * The join key for an extension is its directory (`basename(dirname(path))`), not
+ * the display name: a subfolder resource is shown as `web-access/index.ts` but its
  * report is named `web-access`. A directory name is only usable when it maps to
  * exactly one unique resource path — two unrelated extensions can share a
  * directory name (a user `plan` beside the package's `plan`) and every flat file
@@ -15,25 +16,21 @@
  * for a report with no item) so the cursor survives a rebuild even when two
  * rows share a directory name. Items keep the picker's grouping and order, and
  * a row never invents health: an item without a report carries no glyph and no
- * summary.
+ * summary. Skills skip the report half entirely and take their label and detail
+ * text from the skill index instead.
  */
 
 import { basename, dirname } from "node:path";
 import type { ExtensionReport } from "../../../lib/requirements.ts";
-import { buildEntries } from "../picker/resources.ts";
-import type { ResourceItem } from "../picker/types.ts";
-import type { PanelGroup, PanelModel, PanelRow } from "./types.ts";
+import { buildEntries, resourceKey } from "../picker/resources.ts";
+import type { ResourceItem, ResourceKind } from "../picker/types.ts";
+import type { PanelGroup, PanelModel, PanelRow, SkillInfo } from "./types.ts";
 
 /** The extension directory name that joins a resolved item to its report. */
 export function extensionName(path: string): string {
 	return basename(dirname(path));
 }
 
-/** Unique identity of a resolved resource, independent of the directory name. */
-export function resourceKey(item: ResourceItem): string {
-	return `${item.metadata.source}:${item.path}`;
-}
-
 /** Row key for a report that has no resolved extension item. */
 function reportKey(name: string): string {
 	return `report:${name}`;
@@ -49,11 +46,13 @@ export interface PanelJoinOptions {
 	agentDir: string;
 	/** Narrow to one extension directory or report name, or `undefined` for the full list. */
 	filter?: string;
+	/** Which resource kind the list is, for labels and grouping. */
+	kind?: ResourceKind;
 }
 
 /** Build the merged model for the current items and reports. */
 export function buildPanelModel(options: PanelJoinOptions): PanelModel {
-	const { items, reports, agentDir, filter } = options;
+	const { items, reports, agentDir, filter, kind = "extensions" } = options;
 	const byName = new Map(reports.map((report) => [report.extension, report]));
 
 	// A directory name may claim a report only when exactly one unique resource
@@ -73,7 +72,7 @@ export function buildPanelModel(options: PanelJoinOptions): PanelModel {
 	const rows: PanelRow[] = [];
 	let current: PanelGroup | undefined;
 
-	for (const entry of buildEntries([...items], agentDir)) {
+	for (const entry of buildEntries([...items], agentDir, kind)) {
 		if (entry.kind === "group") {
 			current = { key: entry.key, label: entry.label, count: 0 };
 			groups.push(current);
@@ -101,3 +100,25 @@ export function buildPanelModel(options: PanelJoinOptions): PanelModel {
 
 	return { groups: groups.filter((group) => group.count > 0), rows };
 }
+
+/**
+ * The Skills model: the grouped list an extension screen shows, labelled by the
+ * skill's declared name and carrying what its detail pane needs. There is no
+ * doctor report for a skill, so the only join is to the loaded metadata; a file
+ * Pi refused keeps the name its path gives it and carries the reason.
+ */
+export function buildSkillModel(options: {
+	items: readonly ResourceItem[];
+	index: ReadonlyMap<string, SkillInfo>;
+	agentDir: string;
+}): PanelModel {
+	const model = buildPanelModel({ items: options.items, reports: [], agentDir: options.agentDir, kind: "skills" });
+	return {
+		groups: model.groups,
+		rows: model.rows.map((row) => {
+			const skill = row.item ? options.index.get(row.item.path) : undefined;
+			if (skill === undefined) return row;
+			return { ...row, label: skill.name ?? row.label, skill };
+		}),
+	};
+}