@pellux/goodvibes-tui 2.0.20 → 2.1.0

package/src/{panels → views}/session-maintenance.ts

@@ -4,41 +4,41 @@
  * The canonical evaluator is the SDK version exported from @/runtime/index.ts
  * (via operations.evaluateSessionMaintenance), which reads from configManager.
  * Import the evaluator from there, this module provides only the shared
- * Panel* type surface used across TUI panels and tests; it intentionally does
+ * View* type surface used across TUI views and tests; it intentionally does
  * not re-implement the evaluator.
  */
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 
-export type PanelGuidanceMode = 'off' | 'minimal' | 'guided';
-export type PanelSessionMaintenanceLevel = 'stable' | 'watch' | 'suggest-compact' | 'compacting' | 'needs-repair' | 'unknown';
+export type ViewGuidanceMode = 'off' | 'minimal' | 'guided';
+export type ViewSessionMaintenanceLevel = 'stable' | 'watch' | 'suggest-compact' | 'compacting' | 'needs-repair' | 'unknown';
 
-export interface PanelSessionMaintenanceLineageEntry {
+export interface ViewSessionMaintenanceLineageEntry {
   readonly branchReason?: string;
 }
 
-export interface PanelSessionMaintenanceSession {
-  readonly lineage?: readonly PanelSessionMaintenanceLineageEntry[];
+export interface ViewSessionMaintenanceSession {
+  readonly lineage?: readonly ViewSessionMaintenanceLineageEntry[];
   readonly lastCompactedAt?: number;
   readonly compactionMessageCount?: number;
   readonly compactionState?: string;
 }
 
-export interface PanelSessionMaintenanceInput {
+export interface ViewSessionMaintenanceInput {
   /** ConfigManager used to read behavior.autoCompactThreshold and related keys. */
   readonly configManager: Pick<ConfigManager, 'get'>;
   readonly currentTokens: number;
   readonly contextWindow: number;
   readonly messageCount?: number;
   readonly sessionMemoryCount?: number;
-  readonly session?: PanelSessionMaintenanceSession | null;
+  readonly session?: ViewSessionMaintenanceSession | null;
 }
 
-export interface PanelSessionMaintenanceStatus {
-  readonly level: PanelSessionMaintenanceLevel;
+export interface ViewSessionMaintenanceStatus {
+  readonly level: ViewSessionMaintenanceLevel;
   readonly summary: string;
   readonly reasons: readonly string[];
   readonly nextSteps: readonly string[];
-  readonly guidanceMode: PanelGuidanceMode;
+  readonly guidanceMode: ViewGuidanceMode;
   readonly usagePct: number;
   readonly remainingTokens: number;
   /**

package/src/views/skills-discovery.ts

@@ -0,0 +1,159 @@
+/**
+ * skills-discovery.ts, finding the skills on disk: project-local
+ * (.goodvibes/skills), global (~/.goodvibes/skills) and custom directories,
+ * each SKILL.md parsed for its frontmatter, marketplace-installed ones tagged
+ * with their provenance. Used by /skills, /local review and the Skills modal.
+ */
+
+import { promises as fsPromises } from 'node:fs';
+import { join, sep } from 'node:path';
+import { listInstalledEcosystemEntries, type EcosystemCatalogPathOptions, type ShellPathService } from '@/runtime/index.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+export type SkillOrigin = 'project-local' | 'global' | 'custom';
+
+export interface SkillRecord {
+  name: string;
+  description: string;
+  path: string;
+  origin: SkillOrigin;
+  dependencies: string[];
+  includes: string[];
+  frontmatter: Record<string, string>;
+  /**
+   * Set when this skill's file lives under an installed ecosystem-marketplace
+   * receipt's targetPath, the receipt's provenance summary (e.g. curated
+   * source / signature info), so marketplace-installed skills read as such
+   * instead of looking identical to hand-authored ones.
+   */
+  marketplaceProvenance?: string;
+}
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function getSkillDirectories(cwd: string, homeDir: string): Array<{ root: string; origin: SkillOrigin }> {
+  return [
+    { root: join(cwd, '.goodvibes', 'skills'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', 'tui', 'skills'), origin: 'project-local' },
+    { root: join(homeDir, '.goodvibes', 'skills'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', 'tui', 'skills'), origin: 'global' },
+  ];
+}
+
+async function readSkillFile(path: string, origin: SkillOrigin): Promise<SkillRecord | null> {
+  let content = '';
+  try {
+    content = await fsPromises.readFile(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const body = content.replace(/^---\n[\s\S]*?\n---\n?/, '');
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/, '') ?? 'skill';
+  const description = frontmatter.description ?? frontmatter.summary ?? '';
+  const dependencies = frontmatter.depends_on
+    ? frontmatter.depends_on.split(',').map((item) => item.trim()).filter(Boolean)
+    : [];
+  const includes: string[] = [];
+  const includeRegex = /^@([\w/-]+)/gm;
+  let match: RegExpExecArray | null;
+  while ((match = includeRegex.exec(body)) !== null) {
+    includes.push(match[1]);
+  }
+
+  return {
+    name,
+    description,
+    path,
+    origin,
+    dependencies,
+    includes,
+    frontmatter,
+  };
+}
+
+async function scanSkillDirectory(root: string, origin: SkillOrigin): Promise<SkillRecord[]> {
+  let entries: string[] = [];
+  try {
+    entries = await fsPromises.readdir(root);
+  } catch {
+    return [];
+  }
+
+  const records: SkillRecord[] = [];
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (entry.endsWith('.md')) {
+      const record = await readSkillFile(join(root, entry), origin);
+      if (record) records.push(record);
+      continue;
+    }
+
+    const markerPath = join(root, entry, 'SKILL.md');
+    const record = await readSkillFile(markerPath, origin);
+    if (record) records.push(record);
+  }
+
+  return records;
+}
+
+/**
+ * Tags records whose file lives under an installed ecosystem-marketplace
+ * receipt's targetPath with that receipt's provenance summary. Best-effort:
+ * a lookup failure (e.g. no ecosystem catalogs configured) leaves records
+ * untagged rather than failing skill discovery.
+ */
+function applyMarketplaceProvenance(records: SkillRecord[], ecosystemPaths: EcosystemCatalogPathOptions): SkillRecord[] {
+  let receipts: ReturnType<typeof listInstalledEcosystemEntries>;
+  try {
+    receipts = listInstalledEcosystemEntries('skill', ecosystemPaths);
+  } catch {
+    return records;
+  }
+  if (receipts.length === 0) return records;
+  return records.map((record) => {
+    const receipt = receipts.find((candidate) => record.path === candidate.targetPath || record.path.startsWith(`${candidate.targetPath}${sep}`));
+    if (!receipt) return record;
+    return { ...record, marketplaceProvenance: receipt.provenanceSummary };
+  });
+}
+
+export async function discoverSkills(
+  shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>,
+  ecosystemPaths?: EcosystemCatalogPathOptions,
+): Promise<SkillRecord[]> {
+  const cwd = shellPaths.workingDirectory;
+  const homeDir = shellPaths.homeDirectory;
+  const seen = new Set<string>();
+  const records: SkillRecord[] = [];
+
+  for (const { root, origin } of getSkillDirectories(cwd, homeDir)) {
+    for (const record of await scanSkillDirectory(root, origin)) {
+      if (seen.has(record.name.toLowerCase())) continue;
+      seen.add(record.name.toLowerCase());
+      records.push(record);
+    }
+  }
+
+  const tagged = ecosystemPaths ? applyMarketplaceProvenance(records, ecosystemPaths) : records;
+
+  return tagged.sort((a, b) => {
+    const originRank = a.origin === b.origin
+      ? 0
+      : a.origin === 'project-local'
+        ? -1
+        : 1;
+    return originRank || a.name.localeCompare(b.name);
+  });
+}

package/src/views/view-deps.ts

@@ -0,0 +1,80 @@
+/**
+ * view-deps.ts, what the built-in modals and views are built from.
+ *
+ * Composed once at startup (runtime/bootstrap-shell.ts) and handed to
+ * createShellViews (builtin-views.ts), which builds the always-on read models
+ * (usage, fleet acts and spawn) and registers every config-modal surface.
+ */
+
+import type { ConfigManager, ServiceRegistry, SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import type { Orchestrator, SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
+import type { MemoryAccess } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
+import type { HookActivityTracker, HookDispatcher, HookWorkbench } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
+import type { ProjectPlanningService, KnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
+import type { WorkPlanStore } from '@pellux/goodvibes-sdk/platform/workflow';
+import type { PolicyRuntimeState, SandboxSessionRegistry } from '@/runtime/index.ts';
+import type { UiRuntimeServices } from '../runtime/ui-services.ts';
+import type { PluginsModalManager } from './modals/plugins-modal.ts';
+
+export interface BuiltinViewDeps {
+  readonly providerRegistry: ProviderRegistry;
+  readonly uiServices: UiRuntimeServices;
+  readonly toolRegistry?: ToolRegistry;
+  /** The main orchestrator (session usage and context size). */
+  readonly orchestrator?: Orchestrator;
+  /** The current model's context window in tokens. */
+  readonly getCtxWindow?: () => number;
+  readonly requestRender?: () => void;
+  readonly sandboxSessionRegistry: SandboxSessionRegistry;
+  /** Memory access for the Memory modal (the spine client, which routes to an adopted daemon). */
+  readonly memoryRegistry?: MemoryAccess;
+  readonly pluginManager?: PluginsModalManager;
+  readonly hookDispatcher?: Pick<HookDispatcher, 'listHooks' | 'getChains'>;
+  readonly hookWorkbench?: HookWorkbench;
+  readonly hookActivityTracker?: Pick<HookActivityTracker, 'listRecent'>;
+  readonly knowledgeApi?: KnowledgeApi;
+  /** The files this session edited (the Changes modal's default view). */
+  readonly sessionChangeTracker?: Pick<SessionChangeTracker, 'getChangedFiles'>;
+  /** Report a fleet act's result (late-bound to the command context's print). */
+  readonly fleetActsNotify?: (message: string) => void;
+  /** Hand a spawned session id to the one-key jump affordance (late-bound). */
+  readonly armFixSessionAttach?: (sessionId: string) => void;
+}
+
+/** The deps with everything the modals require resolved from the UI services. */
+export type ResolvedBuiltinViewDeps = BuiltinViewDeps & {
+  readonly configManager: ConfigManager;
+  readonly localUserAuthManager: UserAuthManager;
+  readonly subscriptionManager: SubscriptionManager;
+  readonly serviceRegistry: ServiceRegistry;
+  readonly sessionMemoryStore: SessionMemoryStore;
+  readonly projectPlanningService: ProjectPlanningService;
+  readonly projectPlanningProjectId: string;
+  readonly workPlanStore: WorkPlanStore;
+  readonly policyRuntimeState: PolicyRuntimeState;
+};
+
+function required<T>(value: T | undefined, what: string): T {
+  if (value === undefined) throw new Error(`${what} must be wired at bootstrap for the built-in modals.`);
+  return value;
+}
+
+export function resolveBuiltinViewDeps(deps: BuiltinViewDeps): ResolvedBuiltinViewDeps {
+  const ui = deps.uiServices;
+  return {
+    ...deps,
+    configManager: required(ui.platform.configManager, 'Config manager'),
+    localUserAuthManager: required(ui.platform.localUserAuthManager, 'Local auth manager'),
+    subscriptionManager: required(ui.platform.subscriptionManager, 'Subscription manager'),
+    serviceRegistry: required(ui.platform.serviceRegistry, 'Service registry'),
+    sessionMemoryStore: required(ui.sessions.sessionMemoryStore, 'Session memory store'),
+    projectPlanningService: required(ui.planning.projectPlanningService, 'Project planning service'),
+    projectPlanningProjectId: required(ui.planning.projectPlanningProjectId, 'Project planning project id'),
+    workPlanStore: required(ui.planning.workPlanStore, 'Work plan store'),
+    policyRuntimeState: required(ui.platform.policyRuntimeState, 'Policy runtime state'),
+  };
+}

package/src/views/view-panel-adapter.ts

@@ -0,0 +1,53 @@
+/**
+ * view-panel-adapter.ts, the operator API's panels.list / panels.open, answered
+ * by the modal views.
+ *
+ * THE ONLY PLACE PANE VOCABULARY IS KEPT IN THE TUI. The terminal has no panes:
+ * every view opens as a modal. The names here (ViewPanelAdapter, PanelManagerLike,
+ * getTopPane/getBottomPane, NO_PANES, the `panels` field) are kept on purpose
+ * because they are the SDK's contract, not TUI design:
+ *   - the SDK's IntegrationHelperService serves the operator API verbs
+ *     panels.list and panels.open (and the /api/panels/* HTTP routes) from the
+ *     `panelManager` option, typed PanelManagerLike;
+ *   - remote clients, the web UI and the daemon already speak those verb names.
+ * Renaming them is an SDK and wire change, so the TUI keeps one adapter that
+ * satisfies the contract and translates it: panels.list lists the views a
+ * remote client can open (Agents, Usage, Changes, Notifications, Sessions),
+ * panels.open opens one as its modal, and both pane lists are always empty
+ * because nothing is ever open in a pane. The opener is set by the shell once
+ * the modal host exists. See docs/architecture.md ("The operator API bridge").
+ */
+
+import type { IntegrationHelperService } from '@/runtime/index.ts';
+
+/** The SDK's panel-manager contract, as IntegrationHelperService takes it. */
+type PanelManagerLike = ConstructorParameters<typeof IntegrationHelperService>[0]['panelManager'];
+type PanelPaneLike = ReturnType<PanelManagerLike['getTopPane']>;
+type PanelRegistrationLike = ReturnType<PanelManagerLike['getRegisteredTypes']>[number];
+
+const VIEWS: readonly PanelRegistrationLike[] = [
+  { id: 'agents', name: 'Agents', category: 'views', description: 'Running and finished agents, chains, workflows and hosted sessions; steer, stop, open a transcript' },
+  { id: 'usage', name: 'Usage', category: 'views', description: 'Context pressure, session tokens and cost, per-turn history, per-agent costs, budget alert' },
+  { id: 'changes', name: 'Changes', category: 'views', description: 'Changed files with a tinted diff, semantic summary, hunk staging, review comments and recent commits' },
+  { id: 'notifications', name: 'Notifications', category: 'views', description: 'Everything the notification feed collected, newest first' },
+  { id: 'sessions', name: 'Sessions', category: 'views', description: 'Saved, hosted and cross-surface sessions' },
+];
+
+const NO_PANES: PanelPaneLike = { panels: [], activeIndex: 0 };
+
+export interface ViewPanelAdapter extends PanelManagerLike {
+  /** Set how a view name is opened (returns false when nothing holds it). */
+  setOpener(open: (id: string) => boolean): void;
+}
+
+export function createViewPanelAdapter(): ViewPanelAdapter {
+  let opener: ((id: string) => boolean) | null = null;
+  return {
+    getTopPane: () => NO_PANES,
+    getBottomPane: () => NO_PANES,
+    getRegisteredTypes: () => VIEWS,
+    open: (id: string) => opener?.(id) ?? false,
+    show: () => {},
+    setOpener: (open) => { opener = open; },
+  };
+}

package/src/{panels → views}/workstream-graph-render.ts

@@ -7,7 +7,7 @@
 // blockedReason, orphaned, stalled, agentId), edges (from → to dependency
 // links), and the elastic-pool state (ready/running/atCap/maxSize). This module
 // is a pure string renderer; every line is fit to the given width (no clipping,
-// no horizontal overflow), so the same output drives a panel or a command.
+// no horizontal overflow), so the same output drives a view or a command.
 // ---------------------------------------------------------------------------
 
 import type { OperatorMethodOutput } from '@pellux/goodvibes-sdk';

package/src/core/conversation-fold.ts

@@ -1,101 +0,0 @@
-/**
- * conversation-fold.ts, which transcript rows render FOLDED, and what spacing
- * that earns them.
- *
- * A folded tool result is exactly ONE row: its header, with the preview riding
- * on the same line after the `▸ N lines` badge. It used to be four rows, a
- * `▄▄▄` cap, an interior preview line carrying a second `[▸ N hidden]` count, a
- * `▀▀▀` cap, and a blank after all of it, for one line of text the header had
- * already sized.
- *
- * These predicates live in their own leaf module because TWO callers must agree
- * on them and neither may depend on the other: the row renderer
- * (conversation-rendering.ts) decides how to draw the row, and the line cache
- * (conversation-line-cache.ts) decides the blank separator that follows it. If
- * those two ever disagreed about which rows are folded, a warm cache and a cold
- * rebuild would space the transcript differently, the exact class of bug the
- * cache's byte-identical contract exists to rule out.
- *
- * Everything here is PURE: collapse state is read, never written, so a row can
- * be asked about before it has rendered.
- */
-
-import { foldedToolResult, trailingBlankAfterRow } from '@pellux/goodvibes-terminal-shell';
-import { summarizeToolResult } from '../renderer/tool-result-summary.ts';
-import { isTurnCollapsed, type ConversationRenderContext } from './conversation-render-context.ts';
-import { collapseKeyForNode, type RenderNode } from './conversation-turn-structure.ts';
-import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
-
-/** The subset of a render context these predicates read. */
-type FoldContext = Pick<ConversationRenderContext, 'assistantTurns' | 'collapseState'>;
-
-/**
- * Does a tool-result row render FOLDED, one compact header row with its preview
- * on it, rather than header-plus-expanded-body?
- *
- * An unset collapse key answers the same as the default the row itself will
- * store (collapsed), so asking before and asking after the row renders give the
- * same answer.
- */
-export function isToolResultFolded(
-  message: Extract<ConversationMessageSnapshot, { role: 'tool' }>,
-  collapseState: ReadonlyMap<string, boolean>,
-  collapseKey: string,
-): boolean {
-  // Threading only, the decision, the short-content threshold and the
-  // unset-key default all belong to foldedToolResult(). summarizeToolResult is
-  // this product's own renderer concern, so resolving it stays here: a
-  // summarizable result stays folded even when short, because the one-line
-  // summary is the better row and the raw payload belongs behind the toggle.
-  return foldedToolResult({
-    contentLength: message.content.length,
-    hasSummary: summarizeToolResult(message.toolName, message.content) !== null,
-    storedCollapsed: collapseState.get(collapseKey),
-  });
-}
-
-/** A row that belongs to a tool run: the call itself, or the result under it. */
-function isToolRunNode(node: RenderNode): boolean {
-  return node.kind === 'toolcall' || node.message.role === 'tool';
-}
-
-/**
- * Does this planned row emit exactly one folded tool-result line?
- *
- * A collapsed turn hides the row entirely, so there is no folded row to butt up
- * against the next one.
- */
-function rendersFoldedToolRow(node: RenderNode, context: FoldContext): boolean {
-  if (node.kind === 'toolcall') return false;
-  const message = node.message;
-  if (message.role !== 'tool') return false;
-  if (isTurnCollapsed(context.assistantTurns?.get(node.absIdx), context.collapseState)) return false;
-  return isToolResultFolded(message, context.collapseState, collapseKeyForNode(node));
-}
-
-/**
- * The blank separator that follows a planned row.
- *
- * Branch rows sit tight under their parent, so the blank lands only after the
- * last row of a top-level unit, that is what keeps a turn's whole subtree
- * reading as one block. On top of that, a folded row followed by more tool
- * machinery gets NO blank at all: N consecutive folded results stack as N
- * adjacent single rows. A folded row followed by anything that is not tool
- * machinery keeps its blank, so the run still separates from the prose around
- * it.
- */
-export function trailingBlankAfter(
-  node: RenderNode,
-  next: RenderNode | undefined,
-  context: FoldContext,
-): boolean {
-  // Adaptation only, RenderNode is this product's shape, so reading depth and
-  // node kind off it stays here; the rule those facts feed belongs to
-  // trailingBlankAfterRow(). No `next` at all means end of transcript: neither
-  // a branch row nor tool machinery follows, which is the plain-blank case.
-  return trailingBlankAfterRow({
-    nextIsBranchRow: next !== undefined && next.depth !== 0,
-    nextIsToolMachinery: next !== undefined && isToolRunNode(next),
-    rowRendersFolded: rendersFoldedToolRow(node, context),
-  });
-}