@groeponline/pi-wishcraft 0.17.3

package/src/segments/core.ts

@@ -0,0 +1,256 @@
+import { hostname as osHostname } from "node:os";
+import { basename } from "node:path";
+import type {
+  SegmentContext,
+  SemanticColor,
+  StatusLineSegment,
+} from "../config/types.ts";
+import { applyColor } from "../theme/theme.ts";
+import { getIcons, SEP_DOT, getThinkingText } from "../theme/icons.ts";
+import type { IconSet } from "../theme/icons.ts";
+import { getGitRemoteHost } from "../git/status.ts";
+import type { GitHost } from "../git/status.ts";
+import { color, withIcon, formatDuration } from "./shared.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Segment Implementations
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const modelSegment: StatusLineSegment = {
+  id: "model",
+  render(ctx) {
+    const icons = getIcons();
+    const opts = ctx.options.model ?? {};
+
+    let modelName = ctx.model?.name || ctx.model?.id || "no-model";
+    if (opts.display === "qualified" && ctx.model?.id) {
+      const provider =
+        ctx.model.provider || ctx.model.providerId || ctx.model.providerName;
+      modelName =
+        provider && !ctx.model.id.includes("/")
+          ? `${provider}/${ctx.model.id}`
+          : ctx.model.id;
+    } else if (modelName.startsWith("Claude ")) {
+      modelName = modelName.slice(7);
+    }
+
+    let content = withIcon(icons.model, modelName);
+
+    if (opts.showThinkingLevel !== false && ctx.model?.reasoning) {
+      const level = ctx.thinkingLevel || "off";
+      if (level !== "off") {
+        const thinkingText = getThinkingText(level);
+        if (thinkingText) {
+          content += `${SEP_DOT}${thinkingText}`;
+        }
+      }
+    }
+
+    return { content: color(ctx, "model", content), visible: true };
+  },
+};
+
+export const shellModeSegment: StatusLineSegment = {
+  id: "shell_mode",
+  render(ctx) {
+    if (!ctx.shellModeActive) {
+      return { content: "", visible: false };
+    }
+
+    const shellName = ctx.shellName ?? "shell";
+    const state = ctx.shellRunning ? "run" : "idle";
+    const cwd = ctx.shellCwd ? basename(ctx.shellCwd) : null;
+    const parts = [shellName, state];
+    if (cwd) {
+      parts.push(cwd);
+    }
+
+    return {
+      content: color(ctx, "shellMode", parts.join(SEP_DOT)),
+      visible: true,
+    };
+  },
+};
+
+export const pathSegment: StatusLineSegment = {
+  id: "path",
+  render(ctx) {
+    const icons = getIcons();
+    const opts = ctx.options.path ?? {};
+    const mode = opts.mode ?? "basename";
+
+    let pwd =
+      ctx.shellModeActive && ctx.shellCwd
+        ? ctx.shellCwd
+        : (ctx.cwd ?? process.cwd());
+    const home = process.env.HOME || process.env.USERPROFILE;
+
+    if (mode === "basename") {
+      // Just the last directory component (cross-platform)
+      pwd = basename(pwd) || pwd;
+    } else {
+      // Abbreviate home directory for abbreviated/full modes
+      if (home && pwd.startsWith(home)) {
+        pwd = `~${pwd.slice(home.length)}`;
+      }
+
+      // Strip /work/ prefix (common in containers)
+      if (pwd.startsWith("/work/")) {
+        pwd = pwd.slice(6);
+      }
+
+      // Truncate if too long (only for abbreviated mode)
+      if (mode === "abbreviated") {
+        const maxLen = opts.maxLength ?? 40;
+        if (pwd.length > maxLen) {
+          pwd = `…${pwd.slice(-(maxLen - 1))}`;
+        }
+      }
+    }
+
+    const content = withIcon(icons.folder, pwd);
+    return { content: color(ctx, "path", content), visible: true };
+  },
+};
+
+/**
+ * Icon for the branch label: the origin remote's host logo when hostIcon is
+ * enabled and a remote is known, otherwise the plain branch icon. An
+ * unrecognized remote falls back to the generic git logo.
+ */
+function resolveBranchIcon(icons: IconSet, hostIcon: boolean): string {
+  if (!hostIcon) return icons.branch;
+  const host = getGitRemoteHost();
+  const byHost: Record<GitHost, string> = {
+    github: icons.github,
+    gitlab: icons.gitlab,
+    bitbucket: icons.bitbucket,
+    other: icons.git,
+  };
+  return host ? byHost[host] : icons.branch;
+}
+
+export const gitSegment: StatusLineSegment = {
+  id: "git",
+  render(ctx) {
+    const icons = getIcons();
+    const opts = ctx.options.git ?? {};
+    const { branch, staged, unstaged, untracked } = ctx.git;
+    const gitStatus =
+      staged > 0 || unstaged > 0 || untracked > 0
+        ? { staged, unstaged, untracked }
+        : null;
+
+    if (!branch && !gitStatus) return { content: "", visible: false };
+
+    const isDirty =
+      gitStatus &&
+      (gitStatus.staged > 0 ||
+        gitStatus.unstaged > 0 ||
+        gitStatus.untracked > 0);
+    const showBranch = opts.showBranch !== false;
+    const branchColor: SemanticColor = isDirty ? "gitDirty" : "gitClean";
+
+    // Build content - color branch separately from indicators
+    let content = "";
+    if (showBranch && branch) {
+      // Color just the branch name (icon + branch text)
+      const branchIcon = resolveBranchIcon(icons, opts.hostIcon === true);
+      content = color(ctx, branchColor, withIcon(branchIcon, branch));
+    }
+
+    // Add status indicators (each with their own color, not wrapped)
+    if (gitStatus) {
+      const indicators: string[] = [];
+      if (opts.showUnstaged !== false && gitStatus.unstaged > 0) {
+        indicators.push(
+          applyColor(ctx.theme, "warning", `*${gitStatus.unstaged}`),
+        );
+      }
+      if (opts.showStaged !== false && gitStatus.staged > 0) {
+        indicators.push(
+          applyColor(ctx.theme, "success", `+${gitStatus.staged}`),
+        );
+      }
+      if (opts.showUntracked !== false && gitStatus.untracked > 0) {
+        indicators.push(
+          applyColor(ctx.theme, "muted", `?${gitStatus.untracked}`),
+        );
+      }
+      if (indicators.length > 0) {
+        const indicatorText = indicators.join(" ");
+        if (!content && showBranch === false) {
+          // No branch shown, color the git icon with branch color
+          content =
+            color(ctx, branchColor, icons.git ? `${icons.git} ` : "") +
+            indicatorText;
+        } else {
+          content += content ? ` ${indicatorText}` : indicatorText;
+        }
+      }
+    }
+
+    if (!content) return { content: "", visible: false };
+
+    return { content, visible: true };
+  },
+};
+
+export const timeSpentSegment: StatusLineSegment = {
+  id: "time_spent",
+  render(ctx) {
+    const icons = getIcons();
+    const elapsed = Date.now() - ctx.sessionStartTime;
+    if (elapsed < 1000) return { content: "", visible: false };
+
+    return {
+      content: withIcon(icons.time, formatDuration(elapsed)),
+      visible: true,
+    };
+  },
+};
+
+export const timeSegment: StatusLineSegment = {
+  id: "time",
+  render(ctx) {
+    const icons = getIcons();
+    const opts = ctx.options.time ?? {};
+    const now = new Date();
+
+    let hours = now.getHours();
+    let suffix = "";
+    if (opts.format === "12h") {
+      suffix = hours >= 12 ? "pm" : "am";
+      hours = hours % 12 || 12;
+    }
+
+    const mins = now.getMinutes().toString().padStart(2, "0");
+    let timeStr = `${hours}:${mins}`;
+    if (opts.showSeconds) {
+      timeStr += `:${now.getSeconds().toString().padStart(2, "0")}`;
+    }
+    timeStr += suffix;
+
+    return { content: withIcon(icons.time, timeStr), visible: true };
+  },
+};
+
+export const sessionSegment: StatusLineSegment = {
+  id: "session",
+  render(ctx) {
+    const icons = getIcons();
+    const sessionId = ctx.sessionId;
+    const display = sessionId?.slice(0, 8) || "new";
+
+    return { content: withIcon(icons.session, display), visible: true };
+  },
+};
+
+export const hostnameSegment: StatusLineSegment = {
+  id: "hostname",
+  render() {
+    const icons = getIcons();
+    const name = osHostname().split(".")[0];
+    return { content: withIcon(icons.host, name), visible: true };
+  },
+};

package/src/segments/custom.ts

@@ -0,0 +1,114 @@
+import { execSync } from "node:child_process";
+import type {
+  CustomSegmentConfig,
+  RenderedSegment,
+  SegmentContext,
+  StatusLineSegment,
+  StatusLineSegmentId,
+} from "../config/types.ts";
+import { normalizeExtensionStatusValue } from "../config/powerline-config.ts";
+import { applyColor } from "../theme/theme.ts";
+import { SEP_DOT } from "../theme/icons.ts";
+
+// User-defined computed segments (command/env/static), registered at config time.
+export const customComputedSegments = new Map<string, StatusLineSegment>();
+const commandCache = new Map<string, { at: number; value: string }>();
+
+function runCommandCached(
+  command: string,
+  cacheMs: number | undefined,
+): string | null {
+  // ponytail: simple in-memory cache keyed by command; avoids re-spawning shells every paint
+  const now = Date.now();
+  const cached = commandCache.get(command);
+  if (cached && cacheMs !== undefined && now - cached.at < cacheMs)
+    return cached.value;
+  try {
+    const out = execSync(command, { encoding: "utf8" }).trim();
+    if (cacheMs !== undefined)
+      commandCache.set(command, { at: now, value: out });
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+function makeComputedSegment(
+  id: string,
+  def: CustomSegmentConfig,
+): StatusLineSegment {
+  return {
+    id: `custom:${id}` as StatusLineSegmentId,
+    render(ctx: SegmentContext): RenderedSegment {
+      let text = "";
+      if (def.type === "command") {
+        const out = runCommandCached(def.command, def.cacheMs);
+        if (out === null) return { content: "", visible: false };
+        text = out;
+      } else if (def.type === "env") {
+        const val = process.env[def.env];
+        if (!val) {
+          if (def.fallback === undefined)
+            return { content: "", visible: false };
+          text = def.fallback;
+        } else {
+          text = val;
+        }
+      } else {
+        text = def.text;
+      }
+
+      if (!text) return { content: "", visible: false };
+
+      let content = text;
+      if (def.prefix) content = `${def.prefix}${SEP_DOT}${content}`;
+      if (def.color) content = applyColor(ctx.theme, def.color, content);
+      return { content, visible: true };
+    },
+  };
+}
+
+/** Register user-defined computed segments from settings. Replaces any previously registered. */
+export function registerCustomSegments(
+  defs: Record<string, CustomSegmentConfig>,
+): void {
+  customComputedSegments.clear();
+  for (const [id, def] of Object.entries(defs)) {
+    customComputedSegments.set(id, makeComputedSegment(id, def));
+  }
+}
+
+export function renderCustomSegment(
+  id: `custom:${string}`,
+  ctx: SegmentContext,
+): RenderedSegment {
+  const customItemId = id.slice("custom:".length);
+  const custom = ctx.customItemsById.get(customItemId);
+  if (!custom) return { content: "", visible: false };
+
+  const rawStatus = ctx.extensionStatuses.get(custom.statusKey);
+  const normalizedStatus = rawStatus
+    ? normalizeExtensionStatusValue(rawStatus)
+    : null;
+  if (!normalizedStatus) {
+    return custom.hideWhenMissing
+      ? { content: "", visible: false }
+      : { content: custom.prefix ?? custom.id, visible: true };
+  }
+
+  let content = normalizedStatus;
+  if (custom.prefix) {
+    content = `${custom.prefix}${SEP_DOT}${content}`;
+  }
+  if (custom.color) {
+    content = applyColor(ctx.theme, custom.color, content);
+  }
+
+  return { content, visible: true };
+}
+
+export function isCustomSegmentId(
+  id: StatusLineSegmentId,
+): id is `custom:${string}` {
+  return id.startsWith("custom:");
+}

package/src/segments/index.ts

@@ -0,0 +1,3 @@
+export { countListeningPorts } from "./system.ts";
+export { SEGMENTS, renderSegment } from "./registry.ts";
+export { registerCustomSegments } from "./custom.ts";

package/src/segments/registry.ts

@@ -0,0 +1,87 @@
+import type {
+  BuiltinStatusLineSegmentId,
+  RenderedSegment,
+  SegmentContext,
+  StatusLineSegment,
+  StatusLineSegmentId,
+} from "../config/types.ts";
+import {
+  modelSegment,
+  shellModeSegment,
+  pathSegment,
+  gitSegment,
+  timeSpentSegment,
+  timeSegment,
+  sessionSegment,
+  hostnameSegment,
+} from "./core.ts";
+import {
+  tokenInSegment,
+  tokenOutSegment,
+  tokenTotalSegment,
+  costSegment,
+  contextPctSegment,
+  contextTotalSegment,
+  cacheReadSegment,
+  cacheWriteSegment,
+} from "./usage.ts";
+import {
+  thinkingSegment,
+  subagentsSegment,
+  queueSegment,
+  extensionStatusesSegment,
+  tpsSegment,
+  openPortsSegment,
+} from "./system.ts";
+import {
+  customComputedSegments,
+  renderCustomSegment,
+  isCustomSegmentId,
+} from "./custom.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Segment Registry
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const SEGMENTS: Record<BuiltinStatusLineSegmentId, StatusLineSegment> = {
+  model: modelSegment,
+  shell_mode: shellModeSegment,
+  path: pathSegment,
+  git: gitSegment,
+  thinking: thinkingSegment,
+  subagents: subagentsSegment,
+  queue: queueSegment,
+  token_in: tokenInSegment,
+  token_out: tokenOutSegment,
+  token_total: tokenTotalSegment,
+  cost: costSegment,
+  context_pct: contextPctSegment,
+  context_total: contextTotalSegment,
+  time_spent: timeSpentSegment,
+  time: timeSegment,
+  session: sessionSegment,
+  hostname: hostnameSegment,
+  cache_read: cacheReadSegment,
+  cache_write: cacheWriteSegment,
+  tps: tpsSegment,
+  open_ports: openPortsSegment,
+  extension_statuses: extensionStatusesSegment,
+};
+
+export function renderSegment(
+  id: StatusLineSegmentId,
+  ctx: SegmentContext,
+): RenderedSegment {
+  if (isCustomSegmentId(id)) {
+    const customId = id.slice("custom:".length);
+    const computed = customComputedSegments.get(customId);
+    if (computed) return computed.render(ctx);
+    return renderCustomSegment(id, ctx);
+  }
+
+  const segment = SEGMENTS[id];
+  if (!segment) {
+    return { content: "", visible: false };
+  }
+  return segment.render(ctx);
+}

package/src/segments/shared.ts

@@ -0,0 +1,36 @@
+import type { SegmentContext, SemanticColor } from "../config/types.ts";
+import { fg } from "../theme/theme.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+export function color(
+  ctx: SegmentContext,
+  semantic: SemanticColor,
+  text: string,
+): string {
+  return fg(ctx.theme, semantic, text, ctx.colors);
+}
+
+export function withIcon(icon: string, text: string): string {
+  return icon ? `${icon} ${text}` : text;
+}
+
+export function formatTokens(n: number): string {
+  if (n < 1000) return n.toString();
+  if (n < 10000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1000000) return `${Math.round(n / 1000)}k`;
+  if (n < 10000000) return `${(n / 1000000).toFixed(1)}M`;
+  return `${Math.round(n / 1000000)}M`;
+}
+
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) return `${hours}h${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m${seconds % 60}s`;
+  return `${seconds}s`;
+}