@groeponline/pi-wishcraft 0.17.3

package/src/extension/state.ts

@@ -0,0 +1,159 @@
+import type { PowerlineConfig } from "../config/powerline-config.ts";
+import type { StatusLinePreset } from "../config/types.ts";
+import { PRESETS } from "../config/presets.ts";
+import { BashTranscriptStore } from "../../bash-mode/transcript.ts";
+import { BashCompletionEngine } from "../../bash-mode/completion.ts";
+import { ManagedShellSession } from "../../bash-mode/shell-session.ts";
+import { PowerlineQueueStore } from "../../queue/store.ts";
+import {
+  SessionBranchCache,
+  SessionTokenStatsCache,
+} from "../usage/ledger.ts";
+import { CoreContextUsageCache } from "../usage/context.ts";
+import { createWelcomeDismissScheduler } from "../welcome/auto-dismiss.ts";
+import { createRenderScheduler } from "../render/timer.ts";
+import {
+  resolveShortcutConfig,
+  parseBashModeSettings,
+} from "./shortcuts-config.ts";
+import { readPersistedStashHistory } from "./stash-history.ts";
+import { dismissWelcome } from "./welcome-control.ts";
+import {
+  EDITOR_STATUS_DEFER_MS,
+  STATUS_RENDER_DEBOUNCE_MS,
+} from "./constants.ts";
+import type { RuntimeState } from "./types.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Configuration
+// ═══════════════════════════════════════════════════════════════════════════
+
+export let config: 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: {},
+};
+
+export function setConfig(next: PowerlineConfig): void {
+  config = next;
+}
+
+export let customCompactionEnabled = false;
+
+export function setCustomCompactionEnabled(next: boolean): void {
+  customCompactionEnabled = next;
+}
+
+export const PRESET_NAMES = Object.keys(PRESETS) as StatusLinePreset[];
+
+export function isValidPreset(value: unknown): value is StatusLinePreset {
+  return (
+    typeof value === "string" &&
+    Object.prototype.hasOwnProperty.call(PRESETS, value)
+  );
+}
+
+export function normalizePreset(value: unknown): StatusLinePreset | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+
+  const preset = value.trim().toLowerCase();
+  return isValidPreset(preset) ? preset : null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Runtime state
+// ═══════════════════════════════════════════════════════════════════════════
+
+export function createRuntimeState(
+  startupSettings: Record<string, unknown>,
+): RuntimeState {
+  const resolvedShortcuts = resolveShortcutConfig(startupSettings);
+  const bashModeSettings = parseBashModeSettings(
+    startupSettings,
+    resolvedShortcuts,
+  );
+
+  const rt = {
+    enabled: true,
+    sessionStartTime: Date.now(),
+    sessionGeneration: 0,
+    currentCtx: null,
+    footerDataRef: null,
+    getThinkingLevelFn: null,
+    currentThinkingLevel: null,
+    liveAssistantUsage: null,
+    isStreaming: false,
+    tuiRef: null,
+    restoreFooterStatusRepaintHook: null,
+    stashShortcutInputUnsubscribe: null,
+    dismissWelcomeOverlay: null,
+    welcomeHeaderActive: false,
+    welcomeOverlayShouldDismiss: false,
+    lastUserPrompt: "",
+    showLastPrompt: true,
+    stashedEditorText: null,
+    stashedPromptHistory: readPersistedStashHistory(),
+    currentEditor: null,
+    bashModeActive: false,
+    bashTranscript: new BashTranscriptStore(bashModeSettings),
+    bashCompletionEngine: new BashCompletionEngine(),
+    shellSession: null,
+    queueStore: new PowerlineQueueStore(),
+    powerlineCompacting: false,
+    deliverAfterRetrySettles: false,
+    queueDeliveryTimer: null,
+
+    lastLayoutWidth: 0,
+    lastLayoutResult: null,
+    lastLayoutTimestamp: 0,
+    layoutDirty: true,
+    forceNextLayoutRecompute: false,
+    lastEditorInputAt: 0,
+
+    sessionBranchCache: new SessionBranchCache(),
+    tokenStatsCache: new SessionTokenStatsCache(),
+    coreContextUsageCache: new CoreContextUsageCache(),
+
+    resolvedShortcuts,
+    bashModeSettings,
+  } as RuntimeState;
+
+  rt.welcomeDismissScheduler = createWelcomeDismissScheduler({
+    dismiss: (ctx: unknown) => dismissWelcome(rt, ctx),
+    getGeneration: () => rt.sessionGeneration,
+    isEnabled: () => rt.enabled,
+  });
+
+  rt.statusRenderScheduler = createRenderScheduler(() => {
+    const msSinceInput = Date.now() - rt.lastEditorInputAt;
+    if (
+      rt.layoutDirty &&
+      !rt.forceNextLayoutRecompute &&
+      msSinceInput < EDITOR_STATUS_DEFER_MS
+    ) {
+      rt.statusRenderScheduler.schedule(
+        Math.max(0, EDITOR_STATUS_DEFER_MS - msSinceInput),
+      );
+      return;
+    }
+
+    rt.tuiRef?.requestRender();
+  }, STATUS_RENDER_DEBOUNCE_MS);
+
+  return rt;
+}

package/src/extension/status-line-renderers.ts

@@ -0,0 +1,222 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+import type { SegmentContext } from "../config/types.ts";
+import { getPreset } from "../config/presets.ts";
+import {
+  collectHiddenExtensionStatusKeys,
+  getNotificationExtensionStatuses,
+} from "../config/powerline-config.ts";
+import { ansi, getFgAnsiCode } from "../theme/colors.ts";
+
+import { computeResponsiveLayout } from "./layout.ts";
+import { getQueueContext } from "./queue-context.ts";
+import { buildSegmentContext } from "./segment-context.ts";
+import {
+  EDITOR_STATUS_DEFER_MS,
+  LAYOUT_CACHE_TTL_MS,
+  STREAMING_LAYOUT_CACHE_TTL_MS,
+} from "./constants.ts";
+import { config } from "./state.ts";
+import type { RuntimeState } from "./types.ts";
+
+/**
+ * Get cached responsive layout or compute fresh one.
+ * The segment context scans session state, so keep it stable across render bursts.
+ */
+export function getResponsiveLayout(
+  rt: RuntimeState,
+  width: number,
+  theme: Theme,
+): { topContent: string; secondaryContent: string } {
+  const now = Date.now();
+  const cacheTtl = rt.isStreaming
+    ? STREAMING_LAYOUT_CACHE_TTL_MS
+    : LAYOUT_CACHE_TTL_MS;
+
+  if (rt.lastLayoutResult && rt.lastLayoutWidth === width) {
+    const msSinceInput = now - rt.lastEditorInputAt;
+    const typingRecently = msSinceInput < EDITOR_STATUS_DEFER_MS;
+
+    if (
+      !rt.forceNextLayoutRecompute &&
+      typingRecently &&
+      (rt.layoutDirty || now - rt.lastLayoutTimestamp >= cacheTtl)
+    ) {
+      return rt.lastLayoutResult;
+    }
+
+    if (!rt.layoutDirty && now - rt.lastLayoutTimestamp < cacheTtl) {
+      return rt.lastLayoutResult;
+    }
+  }
+
+  const presetDef = getPreset(config.preset);
+  let segmentCtx: SegmentContext;
+  try {
+    segmentCtx = buildSegmentContext(rt, rt.currentCtx, theme);
+  } catch (error) {
+    const isStale = error instanceof Error && (error.message.includes("This extension instance is stale") || error.message.includes("This extension ctx is stale"));
+    if (!isStale) throw error;
+    rt.currentCtx = null;
+    rt.lastLayoutWidth = width;
+    rt.lastLayoutResult = { topContent: "", secondaryContent: "" };
+    rt.lastLayoutTimestamp = now;
+    rt.layoutDirty = false;
+    rt.forceNextLayoutRecompute = false;
+    return rt.lastLayoutResult;
+  }
+
+  rt.lastLayoutWidth = width;
+  rt.lastLayoutResult = computeResponsiveLayout(segmentCtx, presetDef, width);
+  rt.lastLayoutTimestamp = now;
+  rt.layoutDirty = false;
+  rt.forceNextLayoutRecompute = false;
+
+  return rt.lastLayoutResult;
+}
+
+export function renderPowerlineStatusLines(
+  rt: RuntimeState,
+  width: number,
+): string[] {
+  if (!rt.currentCtx || !rt.footerDataRef) return [];
+
+  const statuses = rt.footerDataRef.getExtensionStatuses();
+  if (!statuses || statuses.size === 0) return [];
+  const hiddenExtensionStatusKeys = collectHiddenExtensionStatusKeys(
+    config.customItems,
+  );
+
+  const notifications: string[] = [];
+  for (const value of getNotificationExtensionStatuses(
+    statuses,
+    hiddenExtensionStatusKeys,
+  )) {
+    const lineContent = ` ${value}`;
+    if (visibleWidth(lineContent) <= width) {
+      notifications.push(lineContent);
+    }
+  }
+
+  return notifications;
+}
+
+export function renderPowerlinePrimaryLines(
+  rt: RuntimeState,
+  width: number,
+  theme: Theme,
+): string[] {
+  if (!rt.currentCtx) return [];
+
+  const layout = getResponsiveLayout(rt, width, theme);
+  return layout.topContent ? [layout.topContent] : [];
+}
+
+export function renderPowerlineSecondaryLines(
+  rt: RuntimeState,
+  width: number,
+  theme: Theme,
+): string[] {
+  if (!rt.currentCtx) return [];
+
+  const layout = getResponsiveLayout(rt, width, theme);
+  return layout.secondaryContent ? [layout.secondaryContent] : [];
+}
+
+export function renderPowerlineQueuePreviewLines(
+  rt: RuntimeState,
+  width: number,
+  theme: Theme,
+): string[] {
+  if (!rt.currentCtx) return [];
+  const summary = rt.queueStore.summarize(
+    getQueueContext(rt.currentCtx),
+    rt.powerlineCompacting,
+  );
+  if (!summary.leadingText) return [];
+
+  const prefix =
+    summary.leadingStatus === "blocked" || summary.leadingStatus === "failed"
+      ? "blocked: "
+      : summary.leadingStatus === "delivering"
+        ? "sending: "
+        : summary.leadingIntent === "idea"
+          ? "idea: "
+          : "queued: ";
+  const text = `${prefix}${summary.leadingText.replace(/\s+/g, " ").trim()}`;
+  const color =
+    summary.leadingStatus === "blocked" || summary.leadingStatus === "failed"
+      ? "warning"
+      : "dim";
+  return [
+    ` ${theme.fg(color, truncateToWidth(text, Math.max(1, width - 1), "…"))}`,
+  ];
+}
+
+export function renderBashTranscriptLines(
+  rt: RuntimeState,
+  width: number,
+  theme: Theme,
+): string[] {
+  if (!rt.bashModeActive) return [];
+
+  const snapshot = rt.bashTranscript.getSnapshot();
+  if (snapshot.commands.length === 0) return [];
+
+  const lines: string[] = [];
+  if (snapshot.truncatedCommands > 0) {
+    lines.push(
+      ` ${theme.fg("dim", `… ${snapshot.truncatedCommands} earlier command${snapshot.truncatedCommands === 1 ? "" : "s"} truncated`)}`,
+    );
+  }
+
+  const recentCommands = snapshot.commands.slice(-4);
+  for (const command of recentCommands) {
+    const promptGlyph =
+      (rt.shellSession?.state.shellName ?? "shell") === "fish" ? ">" : "$";
+    const status =
+      command.exitCode === null
+        ? theme.fg("accent", "running")
+        : command.exitCode === 0
+          ? theme.fg("success", "ok")
+          : theme.fg("error", `exit ${command.exitCode}`);
+    const commandLine = truncateToWidth(
+      command.command.replace(/\s+/g, " ").trim(),
+      Math.max(8, width - 8),
+      "…",
+    );
+    lines.push(
+      ` ${theme.fg("accent", promptGlyph)} ${commandLine} ${theme.fg("dim", "(")}${status}${theme.fg("dim", ")")}`,
+    );
+
+    const outputTail = command.output.slice(-6);
+    for (const outputLine of outputTail) {
+      lines.push(
+        `   ${truncateToWidth(outputLine, Math.max(1, width - 3), "…")}`,
+      );
+    }
+  }
+
+  return lines.slice(-16);
+}
+
+export function renderLastPromptLines(
+  rt: RuntimeState,
+  width: number,
+): string[] {
+  if (rt.bashModeActive || !rt.showLastPrompt || !rt.lastUserPrompt) return [];
+
+  const prefix = ` ${getFgAnsiCode("sep")}↳${ansi.reset} `;
+  const availableWidth = width - visibleWidth(prefix);
+  if (availableWidth < 10) return [];
+
+  let promptText = rt.lastUserPrompt.replace(/\s+/g, " ").trim();
+  if (!promptText) return [];
+
+  promptText = truncateToWidth(promptText, availableWidth, "…");
+
+  const styledPrompt = `${getFgAnsiCode("sep")}${promptText}${ansi.reset}`;
+  const line = `${prefix}${styledPrompt}`;
+  return [truncateToWidth(line, width, "…")];
+}

package/src/extension/types.ts

@@ -0,0 +1,97 @@
+import type { ReadonlyFooterDataProvider } from "@earendil-works/pi-coding-agent";
+
+import type { BashModeSettings } from "../../bash-mode/types.ts";
+import type { BashTranscriptStore } from "../../bash-mode/transcript.ts";
+import type { BashCompletionEngine } from "../../bash-mode/completion.ts";
+import type { ManagedShellSession } from "../../bash-mode/shell-session.ts";
+import type { PowerlineQueueStore } from "../../queue/store.ts";
+import type {
+  SessionAssistantUsage,
+  SessionBranchCache,
+  SessionTokenStatsCache,
+} from "../usage/ledger.ts";
+import type { CoreContextUsageCache } from "../usage/context.ts";
+import type { WelcomeDismissScheduler } from "../welcome/auto-dismiss.ts";
+import type { RenderScheduler } from "../render/timer.ts";
+
+export type ShortcutBinding = string | null;
+
+export interface PowerlineShortcuts {
+  stashHistory: ShortcutBinding;
+  copyEditor: ShortcutBinding;
+  cutEditor: ShortcutBinding;
+  ideaCapture: ShortcutBinding;
+  queueOpen: ShortcutBinding;
+  editorStart: ShortcutBinding;
+  editorEnd: ShortcutBinding;
+  /** Open the powerline main menu (navigate segments / configure / info). */
+  menu: ShortcutBinding;
+  /** Open the powerline info view (full open-ports list, TPS detail). */
+  info: ShortcutBinding;
+}
+
+export type PowerlineShortcutKey = keyof PowerlineShortcuts;
+export type PowerlineShortcutAction =
+  | { kind: "stashHistory" }
+  | { kind: "copyEditor" }
+  | { kind: "cutEditor" }
+  | { kind: "ideaCapture" }
+  | { kind: "queueOpen" }
+  | { kind: "bashMode" }
+  | { kind: "powerlineMenu" }
+  | { kind: "powerlineInfo" };
+
+export interface RuntimeState {
+  enabled: boolean;
+  sessionStartTime: number;
+  sessionGeneration: number;
+  currentCtx: any;
+  footerDataRef: ReadonlyFooterDataProvider | null;
+  getThinkingLevelFn: (() => string) | null;
+  currentThinkingLevel: string | null;
+  liveAssistantUsage: SessionAssistantUsage | null;
+  isStreaming: boolean;
+  tuiRef: any;
+  restoreFooterStatusRepaintHook: (() => void) | null;
+  stashShortcutInputUnsubscribe: (() => void) | null;
+  dismissWelcomeOverlay: (() => void) | null;
+  welcomeHeaderActive: boolean;
+  welcomeOverlayShouldDismiss: boolean;
+  lastUserPrompt: string;
+  showLastPrompt: boolean;
+  stashedEditorText: string | null;
+  stashedPromptHistory: string[];
+  currentEditor: any;
+  bashModeActive: boolean;
+  bashTranscript: BashTranscriptStore;
+  bashCompletionEngine: BashCompletionEngine;
+  shellSession: ManagedShellSession | null;
+  queueStore: PowerlineQueueStore;
+  powerlineCompacting: boolean;
+  deliverAfterRetrySettles: boolean;
+  queueDeliveryTimer: ReturnType<typeof setTimeout> | null;
+
+  // Cache for the top and secondary powerline widgets.
+  lastLayoutWidth: number;
+  lastLayoutResult: {
+    topContent: string;
+    secondaryContent: string;
+  } | null;
+  lastLayoutTimestamp: number;
+  layoutDirty: boolean;
+  forceNextLayoutRecompute: boolean;
+  lastEditorInputAt: number;
+
+  // Cache for token counting: avoid re-scanning the full session event list
+  // on every render (250ms-1s cadence). Revalidates the trailing event's
+  // stats signature so in-place streaming updates are not served stale.
+  sessionBranchCache: SessionBranchCache;
+  tokenStatsCache: SessionTokenStatsCache;
+  coreContextUsageCache: CoreContextUsageCache;
+
+  resolvedShortcuts: PowerlineShortcuts;
+  bashModeSettings: BashModeSettings;
+
+  welcomeDismissScheduler: WelcomeDismissScheduler<any>;
+  statusRenderScheduler: RenderScheduler;
+}

package/src/extension/vibe-command.ts

@@ -0,0 +1,160 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import {
+  generateVibesBatch,
+  getVibeFileCount,
+  getVibeMode,
+  getVibeModel,
+  getVibeTheme,
+  hasVibeFile,
+  parseVibeGenerateArgs,
+  setVibeMode,
+  setVibeModel,
+  setVibeTheme,
+} from "../working-vibes/index.ts";
+
+export async function runVibeCommand(args: string, ctx: any): Promise<void> {
+  const parts = args?.trim().split(/\s+/) || [];
+  const subcommand = parts[0]?.toLowerCase();
+
+  // No args: show current status
+  if (!args || !args.trim()) {
+    const theme = getVibeTheme();
+    const mode = getVibeMode();
+    const model = getVibeModel();
+    let status = `Vibe: ${theme || "off"} | Mode: ${mode} | Model: ${model}`;
+    if (theme && mode === "file") {
+      const count = getVibeFileCount(theme);
+      status +=
+        count > 0 ? ` | File: ${count} vibes` : " | File: not found";
+    }
+    ctx.ui.notify(status, "info");
+    return;
+  }
+
+  // /vibe model [spec] - show or set model
+  if (subcommand === "model") {
+    const modelSpec = parts.slice(1).join(" ");
+    if (!modelSpec) {
+      ctx.ui.notify(`Current vibe model: ${getVibeModel()}`, "info");
+      return;
+    }
+    // Validate format (provider/modelId)
+    if (!modelSpec.includes("/")) {
+      ctx.ui.notify(
+        "Invalid model format. Use: provider/modelId (e.g., openai-codex/gpt-5.4-mini)",
+        "error",
+      );
+      return;
+    }
+    const persisted = setVibeModel(modelSpec);
+    if (persisted) {
+      ctx.ui.notify(`Vibe model set to: ${modelSpec}`, "info");
+    } else {
+      ctx.ui.notify(
+        `Vibe model set to: ${modelSpec} (not persisted; check settings.json)`,
+        "warning",
+      );
+    }
+    return;
+  }
+
+  // /vibe mode [generate|file] - show or set mode
+  if (subcommand === "mode") {
+    const newMode = parts[1]?.toLowerCase();
+    if (!newMode) {
+      ctx.ui.notify(`Current vibe mode: ${getVibeMode()}`, "info");
+      return;
+    }
+    if (newMode !== "generate" && newMode !== "file") {
+      ctx.ui.notify("Invalid mode. Use: generate or file", "error");
+      return;
+    }
+    // Check if file exists when switching to file mode
+    const theme = getVibeTheme();
+    if (newMode === "file" && theme && !hasVibeFile(theme)) {
+      ctx.ui.notify(
+        `No vibe file for "${theme}". Run /vibe generate ${theme} first`,
+        "error",
+      );
+      return;
+    }
+    const persisted = setVibeMode(newMode);
+    if (persisted) {
+      ctx.ui.notify(`Vibe mode set to: ${newMode}`, "info");
+    } else {
+      ctx.ui.notify(
+        `Vibe mode set to: ${newMode} (not persisted; check settings.json)`,
+        "warning",
+      );
+    }
+    return;
+  }
+
+  // /vibe generate <theme> [count] - generate vibes and save to file
+  if (subcommand === "generate") {
+    const parsed = parseVibeGenerateArgs(parts.slice(1));
+    if (!parsed) {
+      ctx.ui.notify("Usage: /vibe generate <theme> [count]", "error");
+      return;
+    }
+
+    const { theme, count } = parsed;
+    ctx.ui.notify(`Generating ${count} vibes for "${theme}"...`, "info");
+
+    const result = await generateVibesBatch(theme, count);
+
+    if (result.success) {
+      ctx.ui.notify(
+        `Generated ${result.count} vibes for "${theme}" → ${result.filePath}`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(`Failed to generate vibes: ${result.error}`, "error");
+    }
+    return;
+  }
+
+  // /vibe off - disable
+  if (subcommand === "off") {
+    const persisted = setVibeTheme(null);
+    if (persisted) {
+      ctx.ui.notify("Vibe disabled", "info");
+    } else {
+      ctx.ui.notify(
+        "Vibe disabled (not persisted; check settings.json)",
+        "warning",
+      );
+    }
+    return;
+  }
+
+  // /vibe <theme> - set theme (preserve original casing)
+  const theme = args.trim();
+  const persisted = setVibeTheme(theme);
+  const mode = getVibeMode();
+  if (mode === "file" && !hasVibeFile(theme)) {
+    const suffix = persisted ? "" : " (not persisted; check settings.json)";
+    ctx.ui.notify(
+      `Vibe set to: ${theme} (file mode, but no file found - run /vibe generate ${theme})${suffix}`,
+      "warning",
+    );
+  } else if (persisted) {
+    ctx.ui.notify(`Vibe set to: ${theme}`, "info");
+  } else {
+    ctx.ui.notify(
+      `Vibe set to: ${theme} (not persisted; check settings.json)`,
+      "warning",
+    );
+  }
+}
+
+export function registerVibeCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("vibe", {
+    description:
+      "Set working message theme. Usage: /vibe [theme|off|mode|model|generate]",
+    handler: async (args, ctx) => {
+      runVibeCommand(args, ctx);
+    },
+  });
+}

package/src/extension/welcome-control.ts

@@ -0,0 +1,27 @@
+import type { RuntimeState } from "./types.ts";
+
+export function dismissWelcome(rt: RuntimeState, ctx: any) {
+  rt.welcomeDismissScheduler.cancel();
+
+  if (rt.dismissWelcomeOverlay) {
+    rt.dismissWelcomeOverlay();
+    rt.dismissWelcomeOverlay = null;
+  } else {
+    // The startup overlay mounts after a delay; dismiss it immediately if it appears later.
+    rt.welcomeOverlayShouldDismiss = true;
+  }
+  if (rt.welcomeHeaderActive) {
+    rt.welcomeHeaderActive = false;
+    ctx.ui.setHeader(undefined);
+  }
+}
+
+export function scheduleDismissWelcome(rt: RuntimeState, ctx: any) {
+  if (
+    !rt.dismissWelcomeOverlay &&
+    rt.welcomeOverlayShouldDismiss &&
+    !rt.welcomeHeaderActive
+  )
+    return;
+  rt.welcomeDismissScheduler.schedule(ctx);
+}