pi-powerline 0.3.1 → 0.4.0

package/README.md

@@ -14,21 +14,49 @@ pi install npm:pi-powerline
 
 ## Settings
 
+Settings are read from both global and project files. Project settings override global settings.
+
+| Location | Scope |
+|----------|-------|
+| `~/.pi/agent/settings.json` | Global |
+| `.pi/settings.json` | Current project |
+
 ```json
 // .pi/settings.json
 {
+  "powerline": true,
   "breadcrumb": "inner",
   "footer": true,
-  "header": true
+  "header": true,
+  "header-info": false
 }
 ```
 
-| Setting | Values | Default |
-|---------|--------|---------|
-| `powerline` | `true` / `false` | `true` |
-| `breadcrumb` | `"hide"` / `"top"` / `"inner"` | `"inner"` |
-| `footer` | `true` / `false` | `true` |
-| `header` | `true` / `false` | `true` |
+| Setting | Values | Default | Effect |
+|---------|--------|---------|--------|
+| `powerline` | `true` / `false` | `true` | Master switch for all pi-powerline UI extensions |
+| `breadcrumb` | `"hide"` / `"top"` / `"inner"` | `"inner"` | Breadcrumb placement |
+| `footer` | `true` / `false` | `true` | Enable custom footer |
+| `header` | `true` / `false` | `true` | Enable custom gradient-logo header |
+| `header-info` | `true` / `false` | `false` | Show header diagnostic info on startup/reload |
+
+### Header info
+
+`header-info` adds diagnostic sections under the header:
+
+- `Context` — loaded system prompt context files, such as `AGENTS.md` and `.pi/APPEND_SYSTEM.md`
+- `Skills` — loaded skills
+- `Prompts` — loaded prompt commands
+- `Extensions` — loaded extension packages or paths
+
+It is only rendered for `startup` and `reload`, never for new sessions. It also requires Pi's `quietStartup` setting to be `true`:
+
+```json
+{
+  "quietStartup": true,
+  "header-info": true
+}
+```
 
 ## Commands
 
@@ -39,6 +67,7 @@ pi install npm:pi-powerline
 | `/powerline breadcrumb:top\|inner\|hide` | Set breadcrumb mode |
 | `/powerline footer:on\|off` | Toggle footer |
 | `/powerline header:on\|off` | Toggle header |
+| `/powerline header-info:on\|off` | Toggle header diagnostic info |
 
 ## License
 

package/header.ts

@@ -4,8 +4,19 @@
  * Shows a gradient-colored PI logo.
  * Controlled by .pi/settings.json → header (boolean, default true).
  */
-import type { ExtensionAPI, ExtensionContext, Theme } from '@mariozechner/pi-coding-agent';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  BeforeAgentStartEvent,
+  SessionStartEvent,
+  SlashCommandInfo,
+  Theme,
+} from '@mariozechner/pi-coding-agent';
 import { VERSION } from '@mariozechner/pi-coding-agent';
+import { truncateToWidth, wrapTextWithAnsi } from '@mariozechner/pi-tui';
 import { readPowerlineSettings } from './settings.ts';
 
 /** Left-to-right ANSI gradient coloring. Spaces are left uncolored. */
@@ -39,6 +50,60 @@ function gradientLine(line: string): string {
   return result;
 }
 
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+
+function visibleLength(line: string): number {
+  return line.replace(ANSI_PATTERN, '').length;
+}
+
+function centerTruncate(line: string, width: number): string {
+  if (width <= 0) return '';
+
+  const length = visibleLength(line);
+  if (length <= width) return line;
+
+  const reset = '\x1b[0m';
+  const start = Math.floor((length - width) / 2);
+  const end = start + width;
+  let activeAnsi = '';
+  let result = '';
+  let visibleIdx = 0;
+
+  for (let i = 0; i < line.length; ) {
+    const ansi = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
+    if (ansi) {
+      const code = ansi[0];
+      activeAnsi = code === reset ? '' : code;
+      if (visibleIdx >= start && visibleIdx < end) {
+        result += code;
+      }
+      i += code.length;
+      continue;
+    }
+
+    const char = Array.from(line.slice(i))[0] ?? '';
+    if (visibleIdx >= start && visibleIdx < end) {
+      if (!result && activeAnsi) result += activeAnsi;
+      result += char;
+    }
+    visibleIdx++;
+    i += char.length;
+  }
+
+  return result.includes('\x1b[') ? result + reset : result;
+}
+
+function centerLine(line: string, width: number): string {
+  const centeredLine = centerTruncate(line, width);
+  const padding = Math.max(0, Math.floor((width - visibleLength(centeredLine)) / 2));
+  return ' '.repeat(padding) + centeredLine;
+}
+
+function centerWrappedLines(line: string, width: number): string[] {
+  if (width <= 0) return [''];
+  return wrapTextWithAnsi(line, width).map((wrappedLine) => centerLine(wrappedLine, width));
+}
+
 const PI_LOGO = [
   '██████████    ',
   '████  ████    ',
@@ -48,44 +113,328 @@ const PI_LOGO = [
   '████      ████',
 ];
 
-function renderLogo(theme: Theme): string[] {
-  const lines = PI_LOGO.map((line) => '  ' + gradientLine(line) + '\x1b[0m');
-  const subtitle = `${theme.fg('muted', '  pi agent')}${theme.fg('dim', ` v${VERSION}`)}`;
-  return ['', ...lines, subtitle];
+function formatReasonStatus(theme: Theme, reason: SessionStartEvent['reason']): string {
+  switch (reason) {
+    case 'startup':
+      return theme.fg('warning', 'Welcome');
+    case 'reload':
+      return theme.fg('success', 'Reloaded');
+    case 'new':
+      return theme.fg('success', 'New Session Started');
+    default:
+      return theme.fg('dim', reason);
+  }
+}
+
+interface HeaderInfo {
+  themeName: string;
+  cwd: string;
+  commands: string[];
+  prompts: string[];
+  skills: string[];
+  extensions: string[];
+  contextItems: string[];
+  contextCount: number;
+  themesCount: number;
+  skillsCount: number;
+  promptsCount: number;
+  extensionsCount: number;
+  commandsCount: number;
+}
+
+function renderBullet(theme: Theme, value: string, width: number): string[] {
+  if (width <= 0) return [''];
+
+  const bulletWidth = Math.min(4, width);
+  const textWidth = Math.max(1, width - bulletWidth);
+  const wrapped = wrapTextWithAnsi(theme.fg('muted', value), textWidth);
+  const bullet = theme.fg('dim', '  • ');
+  const indent = ' '.repeat(bulletWidth);
+
+  return wrapped.map((line, index) => `${index === 0 ? bullet : indent}${line}`);
+}
+
+function renderInfoSection(theme: Theme, title: string, items: string[], width: number): string[] {
+  if (width <= 0) return [''];
+
+  const values = items.length ? items : ['none'];
+  return [
+    truncateToWidth(theme.fg('accent', `[${title}]`), width, ''),
+    ...values.flatMap((item) => renderBullet(theme, item, width)),
+  ];
+}
+
+function renderLogo(
+  theme: Theme,
+  reason: SessionStartEvent['reason'],
+  width: number,
+  info?: HeaderInfo,
+): string[] {
+  const logoWidth = Math.max(...PI_LOGO.map((line) => line.length));
+  const lines = PI_LOGO.map((line) =>
+    centerLine(gradientLine(line.padEnd(logoWidth)) + '\x1b[0m', width),
+  );
+  const subtitle = `${theme.fg('muted', 'pi agent')}${theme.fg('dim', ` v${VERSION}`)}`;
+  const result = [
+    '',
+    ...lines,
+    ...centerWrappedLines(subtitle, width),
+    ...centerWrappedLines(formatReasonStatus(theme, reason), width),
+  ];
+
+  if (!info) return result;
+
+  const counts = [
+    `context: ${info.contextCount}`,
+    `themes: ${info.themesCount}`,
+    `skills: ${info.skillsCount}`,
+    `prompts: ${info.promptsCount}`,
+    `extensions: ${info.extensionsCount}`,
+    `commands: ${info.commandsCount}`,
+  ].join(' | ');
+
+  return [
+    ...result,
+    '',
+    ...centerWrappedLines(theme.fg('dim', counts), width),
+    '',
+    ...renderInfoSection(theme, 'Context', info.contextItems, width),
+    '',
+    ...renderInfoSection(theme, 'Skills', info.skills, width),
+    '',
+    ...renderInfoSection(
+      theme,
+      'Prompts',
+      info.prompts.map((name) => `/${name}`),
+      width,
+    ),
+    '',
+    ...renderInfoSection(theme, 'Extensions', info.extensions, width),
+  ];
+}
+
+function getCommandNames(
+  commands: SlashCommandInfo[],
+  source?: SlashCommandInfo['source'],
+): string[] {
+  return commands
+    .filter((command) => !source || command.source === source)
+    .map((command) => command.name)
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function countUniqueSources(
+  commands: SlashCommandInfo[],
+  source: SlashCommandInfo['source'],
+): number {
+  return new Set(
+    commands
+      .filter((command) => command.source === source)
+      .map((command) => command.sourceInfo?.path || command.sourceInfo?.source || command.name),
+  ).size;
+}
+
+function formatRelativePath(cwd: string, filePath: string): string {
+  return relative(cwd, filePath) || '.';
+}
+
+function formatDisplayPath(cwd: string, filePath: string): string {
+  const home = homedir();
+  const rel = relative(cwd, filePath);
+  if (!rel || (!rel.startsWith('..') && !rel.startsWith('/'))) return rel || '.';
+  if (filePath === home) return '~';
+  if (filePath.startsWith(`${home}/`)) return `~/${relative(home, filePath)}`;
+  return filePath;
+}
+
+function discoverContextItems(cwd: string): string[] {
+  const candidates = ['AGENTS.md', 'AGENTS.MD', 'CLAUDE.md', 'CLAUDE.MD'];
+  const items: string[] = [];
+  const seen = new Set<string>();
+  let currentDir = resolve(cwd);
+  const root = resolve('/');
+
+  while (true) {
+    for (const filename of candidates) {
+      const filePath = join(currentDir, filename);
+      if (existsSync(filePath) && !seen.has(filePath)) {
+        items.unshift(formatRelativePath(cwd, filePath));
+        seen.add(filePath);
+        break;
+      }
+    }
+
+    if (currentDir === root) break;
+    const parentDir = resolve(currentDir, '..');
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+
+  const appendSystemPath = join(cwd, '.pi', 'APPEND_SYSTEM.md');
+  if (existsSync(appendSystemPath)) items.push(formatRelativePath(cwd, appendSystemPath));
+  return items;
+}
+
+function normalizeSystemPromptItems(ctx: ExtensionContext, event: BeforeAgentStartEvent): string[] {
+  const files = event.systemPromptOptions.contextFiles ?? [];
+  const nextItems = files.map((file: { path: string }) => formatRelativePath(ctx.cwd, file.path));
+  if (event.systemPromptOptions.customPrompt) nextItems.unshift('custom system prompt');
+  if (event.systemPromptOptions.appendSystemPrompt) nextItems.push('append system prompt');
+  return nextItems;
+}
+
+function getDirectory(path: string): string {
+  try {
+    return statSync(path).isDirectory() ? path : dirname(path);
+  } catch {
+    return dirname(path);
+  }
+}
+
+function readPackageLabel(startPath: string): string | undefined {
+  let currentDir = getDirectory(startPath);
+  const root = resolve('/');
+
+  while (true) {
+    const packagePath = join(currentDir, 'package.json');
+    if (existsSync(packagePath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packagePath, 'utf-8')) as {
+          name?: string;
+          version?: string;
+        };
+        if (pkg.name) return `${pkg.name}${pkg.version ? ` (v${pkg.version})` : ''}`;
+      } catch {
+        // ignore invalid package metadata
+      }
+    }
+
+    if (currentDir === root) break;
+    const parentDir = resolve(currentDir, '..');
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+
+  return undefined;
+}
+
+function getExtensionItems(cwd: string, commands: SlashCommandInfo[]): string[] {
+  const extensions = new Map<string, string>();
+
+  for (const command of commands) {
+    if (command.source !== 'extension') continue;
+
+    const sourcePath = command.sourceInfo?.baseDir ?? command.sourceInfo?.path;
+    const key = sourcePath || command.sourceInfo?.source || command.name;
+    const label =
+      (sourcePath ? readPackageLabel(sourcePath) : undefined) ??
+      (sourcePath ? formatDisplayPath(cwd, sourcePath) : undefined) ??
+      command.sourceInfo?.source ??
+      command.name;
+    extensions.set(key, label);
+  }
+
+  return Array.from(extensions.values()).sort((a, b) => a.localeCompare(b));
+}
+
+function shouldShowHeaderInfo(ctx: ExtensionContext, reason: SessionStartEvent['reason']): boolean {
+  if (reason !== 'startup' && reason !== 'reload') return false;
+  const settings = readPowerlineSettings(ctx.cwd);
+  if (!settings.quietStartup) return false;
+  return settings['header-info'];
+}
+
+function collectHeaderInfo(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  theme: Theme,
+  contextItems: string[],
+  skillItems: string[],
+): HeaderInfo {
+  const commands = typeof pi.getCommands === 'function' ? pi.getCommands() : [];
+  const allThemes = typeof ctx.ui.getAllThemes === 'function' ? ctx.ui.getAllThemes() : [];
+  const themeName = theme.name ?? ctx.ui.theme?.name ?? 'current';
+  const extensions = getExtensionItems(ctx.cwd, commands);
+
+  return {
+    themeName,
+    cwd: ctx.cwd,
+    commands: getCommandNames(commands),
+    prompts: getCommandNames(commands, 'prompt'),
+    skills: skillItems,
+    extensions,
+    contextItems,
+    contextCount: contextItems.length,
+    themesCount: allThemes.length,
+    skillsCount: skillItems.length,
+    promptsCount: countUniqueSources(commands, 'prompt'),
+    extensionsCount: extensions.length,
+    commandsCount: commands.length,
+  };
 }
 
 /** Register the custom header extension. */
 export function registerHeader(pi: ExtensionAPI) {
   let headerEnabled = false;
+  let currentReason: SessionStartEvent['reason'] = 'startup';
+  let liveTui: any = null;
+  let contextItems: string[] = [];
+  let skillItems: string[] = [];
 
-  function createHeaderComponent() {
-    return (_tui: any, theme: Theme) => ({
-      render(_width: number): string[] {
-        return renderLogo(theme);
-      },
-      invalidate() {},
-    });
+  function createHeaderComponent(ctx: ExtensionContext, reason: SessionStartEvent['reason']) {
+    return (tui: any, theme: Theme) => {
+      liveTui = tui;
+      return {
+        render(width: number): string[] {
+          return renderLogo(
+            theme,
+            reason,
+            width,
+            shouldShowHeaderInfo(ctx, reason)
+              ? collectHeaderInfo(pi, ctx, theme, contextItems, skillItems)
+              : undefined,
+          );
+        },
+        invalidate() {},
+      };
+    };
   }
 
-  function enable(ctx: ExtensionContext) {
+  function enable(ctx: ExtensionContext, reason = currentReason) {
     headerEnabled = true;
-    ctx.ui.setHeader(createHeaderComponent());
+    currentReason = reason;
+    ctx.ui.setHeader(createHeaderComponent(ctx, reason));
   }
 
   function disable(ctx: ExtensionContext) {
     headerEnabled = false;
+    liveTui = null;
     ctx.ui.setHeader(undefined);
   }
 
   // auto-enable on session start if powerline master switch + header setting are both on
-  pi.on('session_start', (_event, ctx) => {
+  pi.on('session_start', (event, ctx) => {
     if (!ctx.hasUI) return;
+    const commands = typeof pi.getCommands === 'function' ? pi.getCommands() : [];
+    contextItems = discoverContextItems(ctx.cwd);
+    skillItems = getCommandNames(commands, 'skill');
     const s = readPowerlineSettings(ctx.cwd);
     if (s.powerline && s.header) {
-      enable(ctx);
+      enable(ctx, event.reason);
     }
   });
 
+  // Refresh with Pi's exact system prompt sources once a prompt is submitted.
+  pi.on('before_agent_start', (event, ctx) => {
+    const nextItems = normalizeSystemPromptItems(ctx, event);
+    const nextSkills = (event.systemPromptOptions.skills ?? [])
+      .map((skill) => skill.name)
+      .sort((a, b) => a.localeCompare(b));
+    if (nextItems.length > 0) contextItems = nextItems;
+    skillItems = nextSkills;
+    liveTui?.requestRender();
+  });
+
   // re-evaluate on model switch
   pi.on('model_select', (_event, ctx) => {
     const s = readPowerlineSettings(ctx.cwd);

package/index.ts

@@ -32,6 +32,12 @@ export default function (pi: ExtensionAPI) {
     default: true,
   });
 
+  pi.registerFlag('header-info', {
+    description: 'Show diagnostic info in custom header',
+    type: 'boolean',
+    default: false,
+  });
+
   // register all sub-extensions
   registerEditor(pi);
   registerFooter(pi);
@@ -83,6 +89,16 @@ export default function (pi: ExtensionAPI) {
           label: 'header:off',
           description: 'Disable custom header',
         },
+        {
+          value: 'header-info:on',
+          label: 'header-info:on',
+          description: 'Show diagnostic info in header',
+        },
+        {
+          value: 'header-info:off',
+          label: 'header-info:off',
+          description: 'Hide diagnostic info in header',
+        },
       ];
       if (!prefix) return items;
       return items.filter((i) => i.value.startsWith(prefix));
@@ -102,12 +118,14 @@ export default function (pi: ExtensionAPI) {
 
       // show status
       if (arg === 'info') {
-        const { powerline, breadcrumb, footer, header } = readPowerlineSettings(ctx.cwd);
+        const settings = readPowerlineSettings(ctx.cwd);
+        const { powerline, breadcrumb, footer, header } = settings;
         const lines = [
           `powerline: ${powerline ? 'on' : 'off'}`,
           `breadcrumb: ${breadcrumb}`,
           `footer: ${footer ? 'on' : 'off'}`,
           `header: ${header ? 'on' : 'off'}`,
+          `header-info: ${settings['header-info'] ? 'on' : 'off'}`,
         ];
         ctx.ui.notify(lines.join('\n'), 'info');
         return;
@@ -117,7 +135,7 @@ export default function (pi: ExtensionAPI) {
       const colonIdx = arg.indexOf(':');
       if (colonIdx === -1) {
         ctx.ui.notify(
-          'Usage: /powerline <info|breadcrumb:hide|top|inner|footer:on|off|header:on|off>',
+          'Usage: /powerline <info|breadcrumb:hide|top|inner|footer:on|off|header:on|off|header-info:on|off>',
           'warning',
         );
         return;
@@ -158,9 +176,19 @@ export default function (pi: ExtensionAPI) {
           msg = `header → ${val}`;
           break;
         }
+        case 'header-info': {
+          if (val !== 'on' && val !== 'off') {
+            ctx.ui.notify('header-info must be: on or off', 'warning');
+            return;
+          }
+          writePowerlineSetting(ctx.cwd, 'header-info', val === 'on');
+          pi.events.emit('powerline_settings_changed', ctx);
+          msg = `header-info → ${val}`;
+          break;
+        }
         default:
           ctx.ui.notify(
-            'Usage: /powerline <breadcrumb:hide|top|inner|footer:on|off|header:on|off>',
+            'Usage: /powerline <breadcrumb:hide|top|inner|footer:on|off|header:on|off|header-info:on|off>',
             'warning',
           );
           return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-powerline",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Powerline-style UI extensions for pi coding agent (custom editor, breadcrumb, footer, header)",
   "homepage": "https://github.com/jwu/pi-powerline#readme",
   "repository": {

package/settings.ts

@@ -1,5 +1,6 @@
 // shared settings read/write helpers for pi-powerline
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 
 export type BreadcrumbMode = 'hide' | 'top' | 'inner';
@@ -9,6 +10,8 @@ export interface PowerlineSettings {
   breadcrumb: BreadcrumbMode;
   footer: boolean;
   header: boolean;
+  'header-info': boolean;
+  quietStartup: boolean;
 }
 
 const DEFAULTS: PowerlineSettings = {
@@ -16,22 +19,48 @@ const DEFAULTS: PowerlineSettings = {
   breadcrumb: 'inner',
   footer: true,
   header: true,
+  'header-info': false,
+  quietStartup: false,
 };
 
-function readSettings(cwd: string): Record<string, unknown> {
-  const settingsPath = join(cwd, '.pi', 'settings.json');
+function getSettingsPath(): string {
+  return join(process.env.HOME ?? homedir(), '.pi', 'agent', 'settings.json');
+}
+
+function getProjectSettingsPath(cwd: string): string {
+  return join(cwd, '.pi', 'settings.json');
+}
+
+function readSettingsFile(settingsPath: string): Record<string, unknown> {
   if (!existsSync(settingsPath)) return {};
   try {
-    return JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    const value = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    return value && typeof value === 'object' && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : {};
   } catch {
     return {};
   }
 }
 
+function mergeSettings(
+  globalSettings: Record<string, unknown>,
+  projectSettings: Record<string, unknown>,
+): Record<string, unknown> {
+  return { ...globalSettings, ...projectSettings };
+}
+
+export function readSettings(cwd: string = process.cwd()): Record<string, unknown> {
+  return mergeSettings(
+    readSettingsFile(getSettingsPath()),
+    readSettingsFile(getProjectSettingsPath(cwd)),
+  );
+}
+
 function writeSettings(cwd: string, settings: Record<string, unknown>): void {
   const settingsDir = join(cwd, '.pi');
   if (!existsSync(settingsDir)) mkdirSync(settingsDir, { recursive: true });
-  writeFileSync(join(settingsDir, 'settings.json'), JSON.stringify(settings, null, 2) + '\n');
+  writeFileSync(getProjectSettingsPath(cwd), JSON.stringify(settings, null, 2) + '\n');
 }
 
 /** Read powerline settings, validating and applying defaults. */
@@ -44,6 +73,9 @@ export function readPowerlineSettings(cwd: string): PowerlineSettings {
       : DEFAULTS.breadcrumb) as BreadcrumbMode,
     footer: typeof s.footer === 'boolean' ? s.footer : DEFAULTS.footer,
     header: typeof s.header === 'boolean' ? s.header : DEFAULTS.header,
+    'header-info':
+      typeof s['header-info'] === 'boolean' ? s['header-info'] : DEFAULTS['header-info'],
+    quietStartup: typeof s.quietStartup === 'boolean' ? s.quietStartup : DEFAULTS.quietStartup,
   };
 }