@groeponline/pi-wishcraft 0.17.3

package/src/config/extension-statuses.ts

@@ -0,0 +1,51 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import type { CustomStatusItem } from "./types.ts";
+
+export function collectHiddenExtensionStatusKeys(
+  customItems: readonly CustomStatusItem[],
+): Set<string> {
+  const hidden = new Set<string>();
+  for (const item of customItems) {
+    if (item.excludeFromExtensionStatuses) hidden.add(item.statusKey);
+  }
+  return hidden;
+}
+
+export function isNotificationExtensionStatus(value: string): boolean {
+  return value.trimStart().startsWith("[");
+}
+
+export function getNotificationExtensionStatuses(
+  statuses: ReadonlyMap<string, string>,
+  hiddenKeys: ReadonlySet<string>,
+): string[] {
+  const notifications: string[] = [];
+  for (const [statusKey, value] of statuses.entries()) {
+    if (
+      hiddenKeys.has(statusKey) ||
+      !value ||
+      !isNotificationExtensionStatus(value)
+    ) {
+      continue;
+    }
+    notifications.push(value);
+  }
+  return notifications;
+}
+
+export function normalizeExtensionStatusValue(value: string): string | null {
+  if (!value || visibleWidth(value) <= 0) {
+    return null;
+  }
+
+  const stripped = value.replace(/(\x1b\[[0-9;]*m|\s|·|[|])+$/, "");
+  return visibleWidth(stripped) > 0 ? stripped : null;
+}
+
+export function normalizeCompactExtensionStatus(value: string): string | null {
+  if (isNotificationExtensionStatus(value)) {
+    return null;
+  }
+
+  return normalizeExtensionStatusValue(value);
+}

package/src/config/layout.ts

@@ -0,0 +1,60 @@
+import type {
+  CustomItemPosition,
+  CustomStatusItem,
+  PresetDef,
+  StatusLineLayout,
+  StatusLineSegmentId,
+} from "./types.ts";
+
+export function mergeSegmentsWithCustomItems(
+  presetDef: PresetDef,
+  customItems: readonly CustomStatusItem[],
+  options: {
+    layout?: StatusLineLayout | null;
+    disabledSegments?: readonly StatusLineSegmentId[];
+  } = {},
+): {
+  leftSegments: StatusLineSegmentId[];
+  rightSegments: StatusLineSegmentId[];
+  secondarySegments: StatusLineSegmentId[];
+} {
+  const layout = options.layout ?? null;
+  const explicitlyPlaced = new Set([
+    ...(layout?.left ?? []),
+    ...(layout?.right ?? []),
+    ...(layout?.secondary ?? []),
+  ]);
+  const disabled = new Set(options.disabledSegments ?? []);
+
+  const buildRow = (
+    position: CustomItemPosition,
+    configured: StatusLineSegmentId[] | undefined,
+    presetSegments: readonly StatusLineSegmentId[],
+  ): StatusLineSegmentId[] => {
+    const segments =
+      configured !== undefined
+        ? [...configured]
+        : presetSegments.filter((id) => !explicitlyPlaced.has(id));
+
+    if (configured === undefined) {
+      for (const item of customItems) {
+        const segmentId: StatusLineSegmentId = `custom:${item.id}`;
+        if (item.position === position && !explicitlyPlaced.has(segmentId)) {
+          segments.push(segmentId);
+        }
+      }
+    }
+
+    return segments.filter((id) => !disabled.has(id));
+  };
+
+  return {
+    leftSegments: buildRow("left", layout?.left, presetDef.leftSegments),
+    rightSegments: buildRow("right", layout?.right, presetDef.rightSegments),
+    secondarySegments: buildRow(
+      "secondary",
+      layout?.secondary,
+      presetDef.secondarySegments ?? [],
+    ),
+  };
+}

package/src/config/parse.ts

@@ -0,0 +1,127 @@
+import {
+  normalizeCustomItems,
+  normalizeCustomPresets,
+  normalizeCustomSegments,
+} from "./custom-items.ts";
+import {
+  isRecord,
+  normalizeCaptureSigil,
+  normalizePlacement,
+  normalizePreset,
+  normalizeSegmentLabels,
+  normalizeSeparator,
+} from "./primitives.ts";
+import { normalizeDisabledSegments, normalizeLayout } from "./segment-ids.ts";
+import { normalizeSegmentOptions } from "./segment-options.ts";
+import type {
+  CustomSegmentConfig,
+  CustomStatusItem,
+  PowerlinePlacement,
+  StatusLineLayout,
+  StatusLinePreset,
+  StatusLineSegmentId,
+  StatusLineSegmentOptions,
+  StatusLineSeparatorStyle,
+} from "./types.ts";
+
+export interface PowerlineConfig {
+  preset: StatusLinePreset;
+  customItems: CustomStatusItem[];
+  disabledSegments: StatusLineSegmentId[];
+  invalidDisabledSegments: string[];
+  layout: StatusLineLayout | null;
+  invalidLayoutSegments: string[];
+  separator: StatusLineSeparatorStyle | null;
+  segmentOptions: StatusLineSegmentOptions;
+  placement: PowerlinePlacement;
+  invalidPlacement: string | null;
+  welcome: boolean;
+  stashSharpSShortcut: boolean;
+  queue: { captureSigil: string | false };
+  /** User-defined computed segments (command/env/static), keyed by id */
+  segments: Record<string, CustomSegmentConfig>;
+  /** User-defined presets, keyed by name */
+  presets: Record<string, import("./types.ts").CustomPresetConfig>;
+  /** Per-segment custom text label shown before the value (e.g. tps -> "speed"). */
+  segmentLabels: Record<string, string>;
+}
+
+export function parsePowerlineConfig(
+  value: unknown,
+  presets: readonly StatusLinePreset[],
+): PowerlineConfig {
+  const defaultConfig: PowerlineConfig = {
+    preset: "default",
+    customItems: [],
+    disabledSegments: [],
+    invalidDisabledSegments: [],
+    layout: null,
+    invalidLayoutSegments: [],
+    separator: null,
+    segmentOptions: {},
+    placement: "above",
+    invalidPlacement: null,
+    welcome: true,
+    stashSharpSShortcut: false,
+    queue: { captureSigil: "#" },
+    segments: {},
+    presets: {},
+    segmentLabels: {},
+  };
+
+  const directPreset = normalizePreset(value, presets);
+  if (directPreset) return { ...defaultConfig, preset: directPreset };
+
+  if (!isRecord(value)) return defaultConfig;
+
+  const customItems = normalizeCustomItems(value.customItems);
+  const customSegments = normalizeCustomSegments(value.segments);
+  const customSegmentIds = new Set(Object.keys(customSegments));
+  const { disabledSegments, invalidDisabledSegments } =
+    normalizeDisabledSegments(
+      value.disabledSegments,
+      customItems,
+      customSegmentIds,
+    );
+  const { layout, invalidLayoutSegments } = normalizeLayout(
+    value.layout,
+    customItems,
+    customSegmentIds,
+  );
+  const { placement, invalidPlacement } = normalizePlacement(value.placement);
+  const queue = isRecord(value.queue)
+    ? { captureSigil: normalizeCaptureSigil(value.queue.captureSigil) }
+    : defaultConfig.queue;
+  const customItemIds = new Set(customItems.map((item) => item.id));
+  const customPresetDefs = normalizeCustomPresets(
+    value.presets,
+    customItemIds,
+    customSegmentIds,
+  );
+  const requestedPreset =
+    typeof value.preset === "string" ? value.preset.trim().toLowerCase() : "";
+  const preset =
+    normalizePreset(value.preset, presets) ??
+    (Object.prototype.hasOwnProperty.call(customPresetDefs, requestedPreset)
+      ? (requestedPreset as StatusLinePreset)
+      : defaultConfig.preset);
+
+  return {
+    preset,
+    customItems,
+    disabledSegments,
+    invalidDisabledSegments,
+    layout,
+    invalidLayoutSegments,
+    separator: normalizeSeparator(value.separator),
+    segmentOptions: normalizeSegmentOptions(value),
+    placement,
+    invalidPlacement,
+    welcome: value.welcome !== false,
+    stashSharpSShortcut: value.stashSharpSShortcut === true,
+    queue,
+    segments: customSegments,
+    presets: customPresetDefs,
+    segmentLabels: normalizeSegmentLabels(value.segmentLabels),
+  };
+}

package/src/config/powerline-config.ts

@@ -0,0 +1,18 @@
+// Barrel file: this module's implementation has been split into cohesive
+// internal files below. Re-exported here to keep a stable public import
+// path (`./config/powerline-config.ts`) for the rest of the codebase.
+export type { PowerlineConfig } from "./parse.ts";
+export { parsePowerlineConfig } from "./parse.ts";
+export { mergeSegmentOptions } from "./segment-options.ts";
+export { mergeSegmentsWithCustomItems } from "./layout.ts";
+export {
+  nextPowerlineSettingWithPreset,
+  nextPowerlineSettingWithOptions,
+} from "./settings-patch.ts";
+export {
+  collectHiddenExtensionStatusKeys,
+  isNotificationExtensionStatus,
+  getNotificationExtensionStatuses,
+  normalizeExtensionStatusValue,
+  normalizeCompactExtensionStatus,
+} from "./extension-statuses.ts";

package/src/config/presets.ts

@@ -0,0 +1,245 @@
+import type { ColorScheme, PresetDef, StatusLinePreset } from "./types.ts";
+import { getDefaultColors } from "../theme/theme.ts";
+import type { CustomPresetConfig } from "./types.ts";
+
+// Get base colors from theme.ts (single source of truth)
+const DEFAULT_COLORS: ColorScheme = getDefaultColors();
+
+// Minimal - more muted, less colorful
+const MINIMAL_COLORS: ColorScheme = {
+  ...DEFAULT_COLORS,
+  model: "text",
+  path: "text",
+  gitClean: "dim",
+};
+
+// Nerd - vibrant colors
+const NERD_COLORS: ColorScheme = {
+  ...DEFAULT_COLORS,
+  model: "accent",
+  path: "success",
+  tokens: "muted",
+  cost: "warning",
+};
+
+const CHEF_COLORS: ColorScheme = {
+  ...DEFAULT_COLORS,
+  model: "text",
+  path: "text",
+  gitClean: "dim",
+  queue: "dim",
+};
+
+export const PRESETS: Record<StatusLinePreset, PresetDef> = {
+  default: {
+    leftSegments: [
+      "model",
+      "thinking",
+      "shell_mode",
+      "path",
+      "git",
+      "queue",
+      "context_pct",
+      "cache_read",
+      "cost",
+    ],
+    rightSegments: [],
+    secondarySegments: ["extension_statuses"],
+    separator: "powerline-thin",
+    colors: DEFAULT_COLORS,
+    segmentOptions: {
+      model: { showThinkingLevel: false },
+      path: { mode: "basename" },
+      git: {
+        showBranch: true,
+        showStaged: true,
+        showUnstaged: true,
+        showUntracked: true,
+      },
+    },
+  },
+
+  minimal: {
+    leftSegments: ["shell_mode", "path", "git"],
+    rightSegments: ["context_pct"],
+    separator: "slash",
+    colors: MINIMAL_COLORS,
+    segmentOptions: {
+      path: { mode: "basename" },
+      git: {
+        showBranch: true,
+        showStaged: false,
+        showUnstaged: false,
+        showUntracked: false,
+      },
+    },
+  },
+
+  compact: {
+    leftSegments: ["model", "shell_mode", "git"],
+    rightSegments: ["queue", "cost", "context_pct"],
+    separator: "powerline-thin",
+    colors: DEFAULT_COLORS,
+    segmentOptions: {
+      model: { showThinkingLevel: false },
+      git: {
+        showBranch: true,
+        showStaged: true,
+        showUnstaged: true,
+        showUntracked: false,
+      },
+    },
+  },
+
+  full: {
+    leftSegments: [
+      "hostname",
+      "model",
+      "thinking",
+      "shell_mode",
+      "path",
+      "git",
+      "queue",
+      "subagents",
+    ],
+    rightSegments: [
+      "token_in",
+      "token_out",
+      "cache_read",
+      "cost",
+      "context_pct",
+      "time_spent",
+      "time",
+      "extension_statuses",
+    ],
+    separator: "powerline",
+    colors: DEFAULT_COLORS,
+    segmentOptions: {
+      model: { showThinkingLevel: false },
+      path: { mode: "abbreviated", maxLength: 50 },
+      git: {
+        showBranch: true,
+        showStaged: true,
+        showUnstaged: true,
+        showUntracked: true,
+      },
+      time: { format: "24h", showSeconds: false },
+    },
+  },
+
+  nerd: {
+    leftSegments: [
+      "hostname",
+      "model",
+      "thinking",
+      "shell_mode",
+      "path",
+      "git",
+      "queue",
+      "session",
+      "subagents",
+    ],
+    rightSegments: [
+      "token_in",
+      "token_out",
+      "cache_read",
+      "cache_write",
+      "cost",
+      "context_pct",
+      "context_total",
+      "time_spent",
+      "time",
+      "extension_statuses",
+    ],
+    separator: "powerline",
+    colors: NERD_COLORS,
+    segmentOptions: {
+      model: { showThinkingLevel: false },
+      path: { mode: "abbreviated", maxLength: 60 },
+      git: {
+        showBranch: true,
+        showStaged: true,
+        showUnstaged: true,
+        showUntracked: true,
+      },
+      time: { format: "24h", showSeconds: true },
+    },
+  },
+
+  ascii: {
+    leftSegments: ["model", "shell_mode", "path", "git"],
+    rightSegments: ["queue", "token_total", "cost", "context_pct"],
+    separator: "ascii",
+    colors: MINIMAL_COLORS,
+    segmentOptions: {
+      model: { showThinkingLevel: true },
+      path: { mode: "abbreviated", maxLength: 40 },
+      git: {
+        showBranch: true,
+        showStaged: true,
+        showUnstaged: true,
+        showUntracked: true,
+      },
+    },
+  },
+
+  chef: {
+    leftSegments: [
+      "hostname",
+      "model",
+      "thinking",
+      "shell_mode",
+      "path",
+      "git",
+      "queue",
+    ],
+    rightSegments: ["tps", "open_ports", "cost", "context_pct", "time"],
+    separator: "slash",
+    colors: CHEF_COLORS,
+    segmentOptions: {
+      model: { showThinkingLevel: false },
+      path: { mode: "basename" },
+      git: {
+        showBranch: true,
+        showStaged: true,
+        showUnstaged: true,
+        showUntracked: true,
+      },
+      time: { format: "24h", showSeconds: false },
+    },
+  },
+};
+
+export function getPreset(name: string): PresetDef {
+  return resolvePreset(name);
+}
+
+// User-defined presets (settings), merged over built-ins at config time.
+const customPresets = new Map<string, PresetDef>();
+
+/** Register user-defined presets from settings. Replaces any previously registered. */
+export function registerCustomPresets(
+  defs: Record<string, CustomPresetConfig>,
+): void {
+  customPresets.clear();
+  for (const [name, def] of Object.entries(defs)) {
+    const presetDef: PresetDef = {
+      leftSegments: def.left ?? [],
+      rightSegments: def.right ?? [],
+      secondarySegments: def.secondary,
+      separator: def.separator ?? "slash",
+      segmentOptions: def.segmentOptions,
+      colors: def.colors,
+    };
+    customPresets.set(name, presetDef);
+  }
+}
+
+/** Resolve a preset by name, checking user-defined presets first. */
+export function resolvePreset(name: string): PresetDef {
+  return (
+    customPresets.get(name) ??
+    PRESETS[name as StatusLinePreset] ??
+    PRESETS.default
+  );
+}

package/src/config/primitives.ts

@@ -0,0 +1,117 @@
+import type {
+  ColorValue,
+  CustomItemPosition,
+  PowerlinePlacement,
+  StatusLinePreset,
+  StatusLineSeparatorStyle,
+} from "./types.ts";
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function normalizePreset(
+  value: unknown,
+  presets: readonly StatusLinePreset[],
+): StatusLinePreset | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return (presets as readonly string[]).includes(normalized)
+    ? (normalized as StatusLinePreset)
+    : null;
+}
+
+export function normalizePlacement(value: unknown): {
+  placement: PowerlinePlacement;
+  invalidPlacement: string | null;
+} {
+  if (value === undefined)
+    return { placement: "above", invalidPlacement: null };
+
+  const normalized =
+    typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (normalized === "above" || normalized === "below") {
+    return { placement: normalized, invalidPlacement: null };
+  }
+
+  return {
+    placement: "above",
+    invalidPlacement: typeof value === "string" ? value.trim() : String(value),
+  };
+}
+
+const SEPARATOR_STYLES = [
+  "powerline",
+  "powerline-thin",
+  "slash",
+  "pipe",
+  "block",
+  "none",
+  "ascii",
+  "dot",
+  "chevron",
+  "star",
+] as const satisfies readonly StatusLineSeparatorStyle[];
+
+export function normalizeSeparator(
+  value: unknown,
+): StatusLineSeparatorStyle | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return (SEPARATOR_STYLES as readonly string[]).includes(normalized)
+    ? (normalized as StatusLineSeparatorStyle)
+    : null;
+}
+
+export function normalizeCustomItemId(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  if (!normalized) return null;
+  return /^[a-zA-Z0-9_-]+$/.test(normalized) ? normalized : null;
+}
+
+export function normalizeCustomItemPosition(
+  value: unknown,
+): CustomItemPosition {
+  if (value === "left" || value === "right" || value === "secondary")
+    return value;
+  return "right";
+}
+
+export function normalizeCustomColor(value: unknown): ColorValue | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized ? (normalized as ColorValue) : undefined;
+}
+
+export function normalizeCustomPrefix(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized ? normalized : undefined;
+}
+
+export function normalizeCaptureSigil(value: unknown): string | false {
+  if (value === false) return false;
+  if (typeof value !== "string") return "#";
+  const normalized = value.trim();
+  return normalized && !/\s/.test(normalized) ? normalized : "#";
+}
+
+export function normalizeCustomSegmentType(
+  value: unknown,
+): "command" | "env" | "static" | null {
+  if (value === "command" || value === "env" || value === "static")
+    return value;
+  return null;
+}
+
+export function normalizeSegmentLabels(raw: unknown): Record<string, string> {
+  const result: Record<string, string> = {};
+  if (!isRecord(raw)) return result;
+  for (const [id, label] of Object.entries(raw)) {
+    if (typeof label === "string" && label.trim()) {
+      result[id] = label.trim();
+    }
+  }
+  return result;
+}