@groeponline/pi-wishcraft 0.17.3

package/src/config/segment-ids.ts

@@ -0,0 +1,114 @@
+import { isRecord, normalizeCustomItemId } from "./primitives.ts";
+import { BUILTIN_STATUS_LINE_SEGMENT_IDS } from "./types.ts";
+import type {
+  CustomStatusItem,
+  StatusLineLayout,
+  StatusLineSegmentId,
+} from "./types.ts";
+
+const BUILTIN_STATUS_LINE_SEGMENT_ID_SET = new Set<string>(
+  BUILTIN_STATUS_LINE_SEGMENT_IDS,
+);
+
+export function normalizeStatusLineSegmentId(
+  value: unknown,
+  customItemIds: ReadonlySet<string>,
+  customSegmentIds: ReadonlySet<string> = new Set(),
+): StatusLineSegmentId | null {
+  if (typeof value !== "string") return null;
+
+  const normalized = value.trim();
+  if (BUILTIN_STATUS_LINE_SEGMENT_ID_SET.has(normalized)) {
+    return normalized as StatusLineSegmentId;
+  }
+
+  const customId = normalized.startsWith("custom:")
+    ? normalizeCustomItemId(normalized.slice("custom:".length))
+    : null;
+  // ponytail: custom: ids resolve to either a user-defined item OR a computed segment
+  return customId &&
+    (customItemIds.has(customId) || customSegmentIds.has(customId))
+    ? `custom:${customId}`
+    : null;
+}
+
+export function normalizeDisabledSegments(
+  raw: unknown,
+  customItems: readonly CustomStatusItem[],
+  customSegmentIds: ReadonlySet<string>,
+): {
+  disabledSegments: StatusLineSegmentId[];
+  invalidDisabledSegments: string[];
+} {
+  if (!Array.isArray(raw))
+    return { disabledSegments: [], invalidDisabledSegments: [] };
+
+  const disabledSegments: StatusLineSegmentId[] = [];
+  const invalidDisabledSegments: string[] = [];
+  const customItemIds = new Set(customItems.map((item) => item.id));
+  const seen = new Set<StatusLineSegmentId>();
+
+  for (const entry of raw) {
+    const segmentId = normalizeStatusLineSegmentId(
+      entry,
+      customItemIds,
+      customSegmentIds,
+    );
+    if (!segmentId) {
+      invalidDisabledSegments.push(
+        typeof entry === "string" ? entry.trim() : String(entry),
+      );
+    } else if (!seen.has(segmentId)) {
+      seen.add(segmentId);
+      disabledSegments.push(segmentId);
+    }
+  }
+
+  return { disabledSegments, invalidDisabledSegments };
+}
+
+export function normalizeLayout(
+  raw: unknown,
+  customItems: readonly CustomStatusItem[],
+  customSegmentIds: ReadonlySet<string>,
+): { layout: StatusLineLayout | null; invalidLayoutSegments: string[] } {
+  if (!isRecord(raw)) return { layout: null, invalidLayoutSegments: [] };
+
+  const layout: StatusLineLayout = {};
+  const invalidLayoutSegments: string[] = [];
+  const customItemIds = new Set(customItems.map((item) => item.id));
+  const globallyPlaced = new Set<StatusLineSegmentId>();
+
+  for (const row of ["left", "right", "secondary"] as const) {
+    const entries = raw[row];
+    if (!Array.isArray(entries)) continue;
+
+    const segments: StatusLineSegmentId[] = [];
+    const seen = new Set<StatusLineSegmentId>();
+    for (const entry of entries) {
+      const segmentId = normalizeStatusLineSegmentId(
+        entry,
+        customItemIds,
+        customSegmentIds,
+      );
+      if (!segmentId) {
+        invalidLayoutSegments.push(
+          `${row}:${typeof entry === "string" ? entry.trim() : String(entry)}`,
+        );
+      } else if (!seen.has(segmentId)) {
+        seen.add(segmentId);
+        if (globallyPlaced.has(segmentId)) {
+          invalidLayoutSegments.push(`${row}:${segmentId}`);
+        } else {
+          globallyPlaced.add(segmentId);
+          segments.push(segmentId);
+        }
+      }
+    }
+    layout[row] = segments;
+  }
+
+  return Object.keys(layout).length > 0
+    ? { layout, invalidLayoutSegments }
+    : { layout: null, invalidLayoutSegments };
+}

package/src/config/segment-options.ts

@@ -0,0 +1,128 @@
+import { normalizeCostCurrency } from "../usage/rates.ts";
+import { isRecord } from "./primitives.ts";
+import type { StatusLineSegmentOptions } from "./types.ts";
+
+export function normalizeSegmentOptions(
+  raw: Record<string, unknown>,
+): StatusLineSegmentOptions {
+  const options: StatusLineSegmentOptions = {};
+
+  if (isRecord(raw.model)) {
+    options.model = {
+      ...(typeof raw.model.showThinkingLevel === "boolean"
+        ? { showThinkingLevel: raw.model.showThinkingLevel }
+        : {}),
+      ...(raw.model.display === "name" || raw.model.display === "qualified"
+        ? { display: raw.model.display }
+        : {}),
+    };
+  }
+
+  if (isRecord(raw.path)) {
+    options.path = {
+      ...(raw.path.mode === "basename" ||
+      raw.path.mode === "abbreviated" ||
+      raw.path.mode === "full"
+        ? { mode: raw.path.mode }
+        : {}),
+      ...(typeof raw.path.maxLength === "number" &&
+      Number.isFinite(raw.path.maxLength) &&
+      raw.path.maxLength > 0
+        ? { maxLength: Math.floor(raw.path.maxLength) }
+        : {}),
+    };
+  }
+
+  if (isRecord(raw.git)) {
+    options.git = {
+      ...(typeof raw.git.showBranch === "boolean"
+        ? { showBranch: raw.git.showBranch }
+        : {}),
+      ...(typeof raw.git.showStaged === "boolean"
+        ? { showStaged: raw.git.showStaged }
+        : {}),
+      ...(typeof raw.git.showUnstaged === "boolean"
+        ? { showUnstaged: raw.git.showUnstaged }
+        : {}),
+      ...(typeof raw.git.showUntracked === "boolean"
+        ? { showUntracked: raw.git.showUntracked }
+        : {}),
+      ...(raw.git.polling === "full" ||
+      raw.git.polling === "branch" ||
+      raw.git.polling === "off"
+        ? { polling: raw.git.polling }
+        : {}),
+      ...(typeof raw.git.hostIcon === "boolean"
+        ? { hostIcon: raw.git.hostIcon }
+        : {}),
+    };
+  }
+
+  if (isRecord(raw.time)) {
+    options.time = {
+      ...(raw.time.format === "12h" || raw.time.format === "24h"
+        ? { format: raw.time.format }
+        : {}),
+      ...(typeof raw.time.showSeconds === "boolean"
+        ? { showSeconds: raw.time.showSeconds }
+        : {}),
+    };
+  }
+
+  if (isRecord(raw.cost)) {
+    const currency = normalizeCostCurrency(raw.cost.currency);
+    options.cost = {
+      ...(raw.cost.subscriptionDisplay === "subscription" ||
+      raw.cost.subscriptionDisplay === "reported-cost" ||
+      raw.cost.subscriptionDisplay === "both"
+        ? { subscriptionDisplay: raw.cost.subscriptionDisplay }
+        : {}),
+      ...(currency ? { currency } : {}),
+    };
+  }
+
+  if (isRecord(raw.context)) {
+    options.context = {
+      ...(raw.context.format === "full" || raw.context.format === "percent"
+        ? { format: raw.context.format }
+        : {}),
+    };
+  }
+
+  if (isRecord(raw.cache_read)) {
+    options.cache_read = {
+      ...(raw.cache_read.format === "tokens" ||
+      raw.cache_read.format === "percent" ||
+      raw.cache_read.format === "both"
+        ? { format: raw.cache_read.format }
+        : {}),
+    };
+  }
+
+  if (isRecord(raw.openPorts)) {
+    options.openPorts = {
+      ...(typeof raw.openPorts.includeUdp === "boolean"
+        ? { includeUdp: raw.openPorts.includeUdp }
+        : {}),
+    };
+  }
+
+  return options;
+}
+
+export function mergeSegmentOptions(
+  defaults: StatusLineSegmentOptions = {},
+  overrides: StatusLineSegmentOptions = {},
+): StatusLineSegmentOptions {
+  return {
+    ...defaults,
+    ...overrides,
+    model: { ...defaults.model, ...overrides.model },
+    path: { ...defaults.path, ...overrides.path },
+    git: { ...defaults.git, ...overrides.git },
+    time: { ...defaults.time, ...overrides.time },
+    cost: { ...defaults.cost, ...overrides.cost },
+    context: { ...defaults.context, ...overrides.context },
+    cache_read: { ...defaults.cache_read, ...overrides.cache_read },
+  };
+}

package/src/config/settings-patch.ts

@@ -0,0 +1,26 @@
+import { isRecord } from "./primitives.ts";
+import type { PowerlineConfig } from "./parse.ts";
+import type { StatusLinePreset } from "./types.ts";
+
+export function nextPowerlineSettingWithPreset(
+  existingPowerlineSetting: unknown,
+  preset: StatusLinePreset,
+): unknown {
+  if (!isRecord(existingPowerlineSetting)) {
+    return preset;
+  }
+  return { ...existingPowerlineSetting, preset };
+}
+
+export function nextPowerlineSettingWithOptions(
+  existingPowerlineSetting: unknown,
+  updates: Partial<
+    Pick<PowerlineConfig, "welcome" | "stashSharpSShortcut" | "placement">
+  >,
+  currentPreset: StatusLinePreset,
+): unknown {
+  if (!isRecord(existingPowerlineSetting)) {
+    return { preset: currentPreset, ...updates };
+  }
+  return { ...existingPowerlineSetting, ...updates };
+}

package/src/config/types.ts

@@ -0,0 +1,277 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { CostCurrencyCode } from "../usage/rates.ts";
+
+// Theme color - either a pi theme color name or a custom hex color
+export type ColorValue = ThemeColor | `#${string}`;
+export type ThemeLike = Pick<Theme, "fg">;
+
+// Semantic color names for segments
+export type SemanticColor =
+  | "model"
+  | "shellMode"
+  | "path"
+  | "gitDirty"
+  | "gitClean"
+  | "thinking"
+  | "thinkingMinimal"
+  | "thinkingLow"
+  | "thinkingMedium"
+  | "context"
+  | "contextWarn"
+  | "contextError"
+  | "cost"
+  | "tokens"
+  | "queue"
+  | "separator"
+  | "border";
+
+// Color scheme mapping semantic names to actual colors
+export type ColorScheme = Partial<Record<SemanticColor, ColorValue>>;
+
+// Built-in segment identifiers
+export const BUILTIN_STATUS_LINE_SEGMENT_IDS = [
+  "model",
+  "shell_mode",
+  "path",
+  "git",
+  "subagents",
+  "queue",
+  "token_in",
+  "token_out",
+  "token_total",
+  "cost",
+  "context_pct",
+  "context_total",
+  "time_spent",
+  "time",
+  "session",
+  "hostname",
+  "cache_read",
+  "cache_write",
+  "thinking",
+  "tps",
+  "open_ports",
+  "extension_statuses",
+] as const;
+
+export type BuiltinStatusLineSegmentId =
+  (typeof BUILTIN_STATUS_LINE_SEGMENT_IDS)[number];
+
+// Segment identifiers (built-in + dynamically registered custom items)
+export type StatusLineSegmentId =
+  BuiltinStatusLineSegmentId | `custom:${string}`;
+
+// Separator styles
+export type StatusLineSeparatorStyle =
+  | "powerline"
+  | "powerline-thin"
+  | "slash"
+  | "pipe"
+  | "block"
+  | "none"
+  | "ascii"
+  | "dot"
+  | "chevron"
+  | "star";
+
+// Preset names
+export type PowerlinePlacement = "above" | "below";
+
+export type StatusLinePreset =
+  "default" | "minimal" | "compact" | "full" | "nerd" | "ascii" | "chef";
+
+// Per-segment options
+export interface StatusLineSegmentOptions {
+  model?: { showThinkingLevel?: boolean; display?: "name" | "qualified" };
+  path?: {
+    mode?: "basename" | "abbreviated" | "full";
+    maxLength?: number;
+  };
+  git?: {
+    showBranch?: boolean;
+    showStaged?: boolean;
+    showUnstaged?: boolean;
+    showUntracked?: boolean;
+    polling?: "full" | "branch" | "off";
+    /** Replace the branch icon with the origin remote's host logo
+     * (GitHub/GitLab/Bitbucket, or a generic git logo). Default false. */
+    hostIcon?: boolean;
+  };
+  time?: { format?: "12h" | "24h"; showSeconds?: boolean };
+  cost?: {
+    subscriptionDisplay?: "subscription" | "reported-cost" | "both";
+    currency?: CostCurrencyCode;
+  };
+  context?: { format?: "full" | "percent" };
+  cache_read?: { format?: "tokens" | "percent" | "both" };
+  openPorts?: {
+    /** Include UDP listeners (mDNS/DHCP/ephemeral) in the count. Default false. */ includeUdp?: boolean;
+  };
+}
+
+export type CustomItemPosition = "left" | "right" | "secondary";
+
+export interface StatusLineLayout {
+  left?: StatusLineSegmentId[];
+  right?: StatusLineSegmentId[];
+  secondary?: StatusLineSegmentId[];
+}
+
+export interface CustomStatusItem {
+  id: string;
+  statusKey: string;
+  position: CustomItemPosition;
+  color?: ColorValue;
+  prefix?: string;
+  hideWhenMissing: boolean;
+  excludeFromExtensionStatuses: boolean;
+}
+
+// Preset definition
+export interface PresetDef {
+  leftSegments: StatusLineSegmentId[];
+  rightSegments: StatusLineSegmentId[];
+  /** Secondary row segments (shown in footer, above sub bar) */
+  secondarySegments?: StatusLineSegmentId[];
+  separator: StatusLineSeparatorStyle;
+  segmentOptions?: StatusLineSegmentOptions;
+  /** Color scheme for this preset */
+  colors?: ColorScheme;
+}
+
+// Separator definition
+export interface SeparatorDef {
+  left: string;
+  right: string;
+  endCaps?: {
+    left: string;
+    right: string;
+    useBgAsFg: boolean;
+  };
+}
+
+// Git status data
+export interface GitStatus {
+  branch: string | null;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+}
+
+// Usage statistics
+export interface QueueSummary {
+  queueCount: number;
+  ideaCount: number;
+  blockedCount: number;
+  compacting: boolean;
+  leadingText: string | null;
+  leadingIntent: "steer" | "follow-up" | "post-compact" | "idea" | null;
+  leadingStatus: "queued" | "blocked" | "delivering" | "sent" | "failed" | null;
+}
+
+export interface UsageStats {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+  // Cumulative cost of subagent child runs (e.g. /parallel, /worker) launched from this session.
+  subagentCost: number;
+}
+
+// Context passed to segment render functions
+export interface SegmentContext {
+  // From pi-mono
+  model:
+    | {
+        id: string;
+        name?: string;
+        provider?: string;
+        providerId?: string;
+        providerName?: string;
+        reasoning?: boolean;
+        contextWindow?: number;
+      }
+    | undefined;
+  thinkingLevel: string;
+  sessionId: string | undefined;
+  cwd?: string;
+
+  // Computed
+  usageStats: UsageStats;
+  contextTokens: number;
+  contextPercent: number;
+  contextWindow: number;
+  autoCompactEnabled: boolean;
+  customCompactionEnabled: boolean;
+  usingSubscription: boolean;
+  queueSummary: QueueSummary;
+  sessionStartTime: number;
+  shellModeActive: boolean;
+  shellRunning: boolean;
+  shellName: string | null;
+  shellCwd: string | null;
+
+  // Git
+  git: GitStatus;
+
+  // Extension statuses
+  extensionStatuses: ReadonlyMap<string, string>;
+  hiddenExtensionStatusKeys: ReadonlySet<string>;
+  customItemsById: ReadonlyMap<string, CustomStatusItem>;
+
+  // Options
+  options: StatusLineSegmentOptions;
+  /** Per-segment custom text labels (from powerline.segmentLabels). */
+  segmentLabels: ReadonlyMap<string, string>;
+
+  // Theming
+  theme: ThemeLike;
+  colors: ColorScheme;
+}
+
+// Rendered segment output
+export interface RenderedSegment {
+  content: string;
+  visible: boolean;
+}
+
+// Segment definition
+export interface StatusLineSegment {
+  id: StatusLineSegmentId;
+  render(ctx: SegmentContext): RenderedSegment;
+}
+
+// User-defined computed segment (configured via settings, no TS needed)
+export type CustomSegmentConfig =
+  | {
+      type: "command";
+      command: string;
+      prefix?: string;
+      color?: ColorValue;
+      /** Cache command output for this many ms to avoid re-running every paint */
+      cacheMs?: number;
+    }
+  | {
+      type: "env";
+      env: string;
+      prefix?: string;
+      color?: ColorValue;
+      fallback?: string;
+    }
+  | {
+      type: "static";
+      text: string;
+      prefix?: string;
+      color?: ColorValue;
+    };
+
+// User-defined preset (configured via settings, merges with built-ins)
+export interface CustomPresetConfig {
+  left?: StatusLineSegmentId[];
+  right?: StatusLineSegmentId[];
+  secondary?: StatusLineSegmentId[];
+  separator?: StatusLineSeparatorStyle;
+  colors?: ColorScheme;
+  segmentOptions?: StatusLineSegmentOptions;
+}

package/src/core/frontmatter.ts

@@ -0,0 +1,40 @@
+/**
+ * frontmatter.ts
+ * ------------------------------------------------------------------------
+ * Utility for stripping YAML frontmatter from markdown/text files.
+ * Used by skills system to extract the actual content from skill files.
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * Strips YAML frontmatter from a text file.
+ * Frontmatter is delimited by --- at the start and end.
+ * 
+ * @param content - The full file content including potential frontmatter
+ * @returns The content with frontmatter removed
+ */
+export function stripFrontmatter(content: string): string {
+	const lines = content.split("\n");
+	
+	// Check if file starts with frontmatter delimiter
+	if (lines[0]?.trim() !== "---") {
+		return content;
+	}
+	
+	// Find the closing delimiter
+	let endIndex = -1;
+	for (let i = 1; i < lines.length; i++) {
+		if (lines[i]?.trim() === "---") {
+			endIndex = i;
+			break;
+		}
+	}
+	
+	// If no closing delimiter found, return original content
+	if (endIndex === -1) {
+		return content;
+	}
+	
+	// Return everything after the frontmatter without changing user-authored whitespace
+	return lines.slice(endIndex + 1).join("\n");
+}

package/src/editor/autocomplete-chain.ts

@@ -0,0 +1,41 @@
+import type { AutocompleteProvider } from "@earendil-works/pi-tui";
+
+function isObject(val: unknown): val is Record<string, unknown> {
+  return val !== null && typeof val === "object";
+}
+
+function isProvider(val: unknown): val is AutocompleteProvider {
+  if (!isObject(val)) return false;
+  return typeof val.getSuggestions === "function" && typeof val.applyCompletion === "function";
+}
+
+export function getEditorAutocompleteProvider(sourceEditor: unknown): AutocompleteProvider | undefined {
+  if (!isObject(sourceEditor) || !("autocompleteProvider" in sourceEditor)) {
+    return undefined;
+  }
+  const provider = sourceEditor.autocompleteProvider;
+  if (isProvider(provider)) {
+    return provider;
+  }
+  return undefined;
+}
+
+export function passAutocompleteProviderThroughPreviousEditor(
+  provider: AutocompleteProvider,
+  previousEditor: unknown,
+): AutocompleteProvider {
+  if (!isObject(previousEditor)) {
+    return provider;
+  }
+  
+  if ("setAutocompleteProvider" in previousEditor && typeof previousEditor.setAutocompleteProvider === "function") {
+    previousEditor.setAutocompleteProvider(provider);
+  }
+
+  const existingProvider = getEditorAutocompleteProvider(previousEditor);
+  if (existingProvider !== undefined) {
+    return existingProvider;
+  }
+  
+  return provider;
+}

package/src/extension/activate.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { parsePowerlineConfig } from "../config/powerline-config.ts";
+import { registerCustomPresets } from "../config/presets.ts";
+import { registerCustomSegments } from "../segments/index.ts";
+import { readSettings } from "./settings-io.ts";
+import { registerSessionLifecycle } from "./session-lifecycle.ts";
+import { registerCommands } from "./commands.ts";
+import { setupInlineInvocation } from "./skills/inline-invocation.ts";
+import {
+  config,
+  createRuntimeState,
+  PRESET_NAMES,
+  setConfig,
+} from "./state.ts";
+
+export default function powerlineFooter(pi: ExtensionAPI) {
+  const startupSettings = readSettings();
+  setConfig(parsePowerlineConfig(startupSettings.powerline, PRESET_NAMES));
+  registerCustomSegments(config.segments);
+  registerCustomPresets(config.presets);
+
+  const rt = createRuntimeState(startupSettings);
+
+  registerSessionLifecycle(pi, rt);
+  registerCommands(pi, rt);
+  setupInlineInvocation(pi, rt);
+}