@groeponline/pi-wishcraft 0.17.3

package/src/extension/menu-views.ts

@@ -0,0 +1,393 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  type SelectItem,
+  SelectList,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+import { execSync } from "node:child_process";
+
+import type { StatusLinePreset } from "../config/types.ts";
+import { getPreset, PRESETS } from "../config/presets.ts";
+import { mergeSegmentsWithCustomItems } from "../config/powerline-config.ts";
+import { writePowerlinePresetSetting } from "./settings-io.ts";
+import { renderSegmentWithWidth } from "./layout.ts";
+import {
+  buildSegmentContext,
+  requestImmediateStatusRender,
+} from "./segment-context.ts";
+import { config, setConfig } from "./state.ts";
+import type { RuntimeState } from "./types.ts";
+
+export function overlaySelectListTheme(theme: Theme) {
+  return {
+    selectedPrefix: (text: string) => theme.fg("accent", text),
+    selectedText: (text: string) => theme.fg("accent", text),
+    description: (text: string) => theme.fg("muted", text),
+    scrollInfo: (text: string) => theme.fg("dim", text),
+    noMatch: (text: string) => theme.fg("warning", text),
+  };
+}
+
+export async function showSelectOverlay(
+  ctx: any,
+  title: string,
+  hint: string,
+  items: SelectItem[],
+  maxVisible: number,
+): Promise<SelectItem | null> {
+  return ctx.ui.custom(
+    (
+      tui: any,
+      theme: Theme,
+      _keybindings: any,
+      done: (result: SelectItem | null) => void,
+    ) => {
+      const selectList = new SelectList(
+        items,
+        maxVisible,
+        overlaySelectListTheme(theme),
+      );
+      const border = (text: string) => theme.fg("dim", text);
+      const wrapRow = (text: string, innerWidth: number): string => {
+        return `${border("│")}${truncateToWidth(text, innerWidth, "…", true)}${border("│")}`;
+      };
+
+      selectList.onSelect = (item) => done(item);
+      selectList.onCancel = () => done(null);
+
+      return {
+        render: (width: number) => {
+          const innerWidth = Math.max(1, width - 2);
+          const lines: string[] = [];
+
+          lines.push(border(`╭${"─".repeat(innerWidth)}╮`));
+          lines.push(
+            wrapRow(theme.fg("accent", theme.bold(title)), innerWidth),
+          );
+          lines.push(border(`├${"─".repeat(innerWidth)}┤`));
+
+          for (const line of selectList.render(innerWidth)) {
+            lines.push(wrapRow(line, innerWidth));
+          }
+
+          lines.push(border(`├${"─".repeat(innerWidth)}┤`));
+          lines.push(wrapRow(theme.fg("dim", hint), innerWidth));
+          lines.push(border(`╰${"─".repeat(innerWidth)}╯`));
+
+          return lines;
+        },
+        invalidate: () => selectList.invalidate(),
+        handleInput: (data: string) => {
+          selectList.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+    {
+      overlay: true,
+      overlayOptions: () => ({
+        verticalAlign: "center",
+        horizontalAlign: "center",
+      }),
+    },
+  );
+}
+
+/** Full open-ports list as a scrollable overlay (the Info view). */
+export async function showOpenPortsList(ctx: any): Promise<void> {
+  try {
+    const includeUdp = config.segmentOptions?.openPorts?.includeUdp === true;
+    const proto = includeUdp ? "-tuln" : "-tln";
+    const stdout = execSync(`ss ${proto} 2>/dev/null`, { encoding: "utf8" });
+    const lines = stdout
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean);
+    const start = /^(Proto|Netid|State|Local)/.test(lines[0] ?? "") ? 1 : 0;
+    const rows = lines.slice(start);
+    if (rows.length === 0) {
+      ctx.ui.notify("No listening sockets", "info");
+      return;
+    }
+    const items: SelectItem[] = rows.map((line) => ({
+      label: line,
+      value: line,
+    }));
+    const picked = await showSelectOverlay(
+      ctx,
+      "Open ports",
+      "↑↓ navigate · enter copy · esc close",
+      items,
+      Math.min(items.length, 24),
+    );
+    if (picked) ctx.ui.notify(`Port: ${picked.value}`, "info");
+  } catch (error) {
+    ctx.ui.notify(
+      `Failed to list ports: ${error instanceof Error ? error.message : String(error)}`,
+      "error",
+    );
+  }
+}
+
+/** Configure sub-menu: preset, TPS value/label, ports UDP, segment labels. */
+export async function configurePowerline(
+  rt: RuntimeState,
+  ctx: any,
+): Promise<void> {
+  const choice = await ctx.ui.select("Powerline · configure", [
+    "Change preset",
+    "Set TPS value (POWERLINE_TPS)",
+    "Clear TPS override (use live)",
+    "Toggle UDP in open-ports",
+    "Set segment label…",
+    "Show current config",
+  ]);
+  if (!choice) return;
+  if (choice === "Change preset") {
+    const names = Object.keys(PRESETS) as StatusLinePreset[];
+    const picked = await ctx.ui.select("Preset", names);
+    if (picked) {
+      setConfig({ ...config, preset: picked as StatusLinePreset });
+      writePowerlinePresetSetting(
+        picked as StatusLinePreset,
+        ctx.cwd ?? process.cwd(),
+      );
+      ctx.ui.notify(`Preset: ${picked} (saved)`, "info");
+      requestImmediateStatusRender(rt, { deferDuringTyping: false });
+    }
+    return;
+  }
+  if (choice === "Set TPS value (POWERLINE_TPS)") {
+    const val = await ctx.ui.input(
+      "TPS value",
+      process.env.POWERLINE_TPS || "",
+    );
+    if (val && val.trim()) {
+      process.env.POWERLINE_TPS = val.trim();
+      ctx.ui.notify(`TPS override set: ${val.trim()}`, "info");
+      requestImmediateStatusRender(rt, { deferDuringTyping: false });
+    }
+    return;
+  }
+  if (choice === "Clear TPS override (use live)") {
+    delete process.env.POWERLINE_TPS;
+    ctx.ui.notify("TPS override cleared (live rate)", "info");
+    requestImmediateStatusRender(rt, { deferDuringTyping: false });
+    return;
+  }
+  if (choice === "Toggle UDP in open-ports") {
+    const now = config.segmentOptions?.openPorts?.includeUdp === true;
+    setConfig({
+      ...config,
+      segmentOptions: {
+        ...config.segmentOptions,
+        openPorts: { includeUdp: !now },
+      },
+    });
+    ctx.ui.notify(`Open-ports UDP: ${!now ? "on" : "off"}`, "info");
+    requestImmediateStatusRender(rt, { deferDuringTyping: false });
+    return;
+  }
+  if (choice === "Set segment label…") {
+    const id = await ctx.ui.input("Segment id", "tps");
+    if (!id) return;
+    const label = await ctx.ui.input(
+      "Label text",
+      config.segmentLabels[id] ?? "",
+    );
+    if (label === undefined) return;
+    const labels = { ...config.segmentLabels };
+    if (label.trim()) labels[id] = label.trim();
+    else delete labels[id];
+    setConfig({ ...config, segmentLabels: labels });
+    ctx.ui.notify(`Label ${id}: ${label.trim() || "(cleared)"}`, "info");
+    requestImmediateStatusRender(rt, { deferDuringTyping: false });
+    return;
+  }
+  if (choice === "Show current config") {
+    const summary = [
+      `preset: ${config.preset}`,
+      `separator: ${config.separator ?? "(preset default)"}`,
+      `tps: ${process.env.POWERLINE_TPS || "(live)"}`,
+      `open_ports UDP: ${config.segmentOptions?.openPorts?.includeUdp ? "on" : "off"}`,
+      `disabled: ${config.disabledSegments.join(",") || "(none)"}`,
+      `labels: ${Object.keys(config.segmentLabels).join(",") || "(none)"}`,
+    ].join("  ·  ");
+    ctx.ui.notify(summary, "info");
+    return;
+  }
+}
+
+/** Activate a segment picked from the navigator (Enter). */
+export async function activateSegment(
+  rt: RuntimeState,
+  ctx: any,
+  picked: { id: string; label: string },
+): Promise<void> {
+  const id = picked.id;
+  if (id === "__none__") return;
+  if (id === "tps") {
+    const current = process.env.POWERLINE_TPS || "(live, auto)";
+    ctx.ui.notify(
+      `TPS: ${current} — set via Configure or /tps <value>`,
+      "info",
+    );
+    return;
+  }
+  if (id === "open_ports") {
+    await showOpenPortsList(ctx);
+    return;
+  }
+  if (id === "git") {
+    ctx.ui.notify(
+      `git branch: ${rt.footerDataRef?.getGitBranch() ?? "(no repo)"}`,
+      "info",
+    );
+    return;
+  }
+  if (id === "cost") {
+    ctx.ui.notify("Use /cost for the cost breakdown", "info");
+    return;
+  }
+  if (id === "context_pct" || id === "context_total") {
+    ctx.ui.notify("Context window shown in the bar", "info");
+    return;
+  }
+  if (id === "queue") {
+    ctx.ui.notify("Use /ideas to work the queue", "info");
+    return;
+  }
+  const value = picked.label.replace(/^\S+\s+/, "");
+  ctx.ui.notify(`${id}: ${value}`, "info");
+}
+
+/** Main powerline menu: navigate / configure / info / toggle. */
+export async function showPowerlineMainMenu(
+  rt: RuntimeState,
+  ctx: any,
+): Promise<void> {
+  rt.currentCtx = ctx;
+  const choice = await ctx.ui.select("Powerline", [
+    "Navigate segments",
+    "Configure…",
+    "Open ports (full list)",
+    "TPS detail",
+    "Toggle powerline",
+  ]);
+  if (!choice) return;
+  if (choice === "Navigate segments") {
+    const picked = await showSegmentNavigator(rt, ctx);
+    if (picked) await activateSegment(rt, ctx, picked);
+    return;
+  }
+  if (choice === "Configure…") {
+    await configurePowerline(rt, ctx);
+    return;
+  }
+  if (choice === "Open ports (full list)") {
+    await showOpenPortsList(ctx);
+    return;
+  }
+  if (choice === "TPS detail") {
+    const live = process.env.POWERLINE_TPS
+      ? `(override ${process.env.POWERLINE_TPS})`
+      : "(live 1s window)";
+    ctx.ui.notify(`TPS ${live}`, "info");
+    return;
+  }
+  if (choice === "Toggle powerline") {
+    ctx.ui.notify("Use /powerline to toggle", "info");
+    return;
+  }
+}
+
+/** Navigable overlay that mirrors the live powerline segments; arrow keys move, Enter activates. */
+export async function showSegmentNavigator(
+  rt: RuntimeState,
+  ctx: any,
+): Promise<{ id: string; label: string } | null> {
+  return ctx.ui.custom(
+    (
+      tui: any,
+      theme: Theme,
+      _keybindings: any,
+      done: (result: { id: string; label: string } | null) => void,
+    ) => {
+      // Build live segment values now that we have a theme
+      const segCtx = buildSegmentContext(rt, ctx, theme);
+      const presetDef = getPreset(config.preset);
+      const merged = mergeSegmentsWithCustomItems(
+        presetDef,
+        config.customItems,
+        {
+          layout: config.layout,
+          disabledSegments: config.disabledSegments,
+        },
+      );
+      const ids = [
+        ...merged.leftSegments,
+        ...merged.rightSegments,
+        ...merged.secondarySegments,
+      ];
+      const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
+      const items: SelectItem[] = [];
+      for (const id of ids) {
+        const rendered = renderSegmentWithWidth(id, segCtx);
+        if (!rendered.visible) continue;
+        const value = stripAnsi(rendered.content).trim() || "(empty)";
+        items.push({ label: `${id}  ${value}`, value: id });
+      }
+      if (items.length === 0) {
+        items.push({ label: "(no visible segments)", value: "__none__" });
+      }
+      const selectList = new SelectList(
+        items,
+        Math.min(items.length, 20),
+        overlaySelectListTheme(theme),
+      );
+      const border = (text: string) => theme.fg("dim", text);
+      const wrapRow = (text: string, innerWidth: number) =>
+        `${border("│")}${truncateToWidth(text, innerWidth, "…", true)}${border("│")}`;
+      selectList.onSelect = (item) =>
+        done({ id: item.value, label: item.label });
+      selectList.onCancel = () => done(null);
+      return {
+        render: (width: number) => {
+          const innerWidth = Math.max(1, width - 2);
+          const lines: string[] = [];
+          lines.push(border(`╭${"─".repeat(innerWidth)}╮`));
+          lines.push(
+            wrapRow(
+              theme.fg("accent", theme.bold("Powerline segments")),
+              innerWidth,
+            ),
+          );
+          lines.push(border(`├${"─".repeat(innerWidth)}┤`));
+          for (const line of selectList.render(innerWidth))
+            lines.push(wrapRow(line, innerWidth));
+          lines.push(border(`├${"─".repeat(innerWidth)}┤`));
+          lines.push(
+            wrapRow(
+              theme.fg("dim", "↑↓ navigate · enter activate · esc cancel"),
+              innerWidth,
+            ),
+          );
+          lines.push(border(`╰${"─".repeat(innerWidth)}╯`));
+          return lines;
+        },
+        invalidate: () => selectList.invalidate(),
+        handleInput: (data: string) => {
+          selectList.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+    {
+      overlay: true,
+      overlayOptions: () => ({
+        verticalAlign: "center",
+        horizontalAlign: "center",
+      }),
+    },
+  );
+}

package/src/extension/powerline-widgets.ts

@@ -0,0 +1,95 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+
+import { resetLayoutCache, requestStatusRender } from "./segment-context.ts";
+import {
+  renderBashTranscriptLines,
+  renderLastPromptLines,
+  renderPowerlinePrimaryLines,
+  renderPowerlineQueuePreviewLines,
+  renderPowerlineSecondaryLines,
+  renderPowerlineStatusLines,
+} from "./status-line-renderers.ts";
+import { config } from "./state.ts";
+import type { RuntimeState } from "./types.ts";
+
+export function installPowerlineWidgets(rt: RuntimeState, ctx: any) {
+  ctx.ui.setWidget(
+    "powerline-status",
+    () => ({
+      dispose() {},
+      invalidate() {
+        requestStatusRender(rt);
+      },
+      render(width: number): string[] {
+        return renderPowerlineStatusLines(rt, width);
+      },
+    }),
+    { placement: "aboveEditor" },
+  );
+
+  ctx.ui.setWidget(
+    "powerline-top",
+    (_tui: any, theme: Theme) => ({
+      dispose() {},
+      invalidate() {
+        resetLayoutCache(rt);
+      },
+      render(width: number): string[] {
+        return renderPowerlinePrimaryLines(rt, width, theme);
+      },
+    }),
+    {
+      placement: config.placement === "below" ? "belowEditor" : "aboveEditor",
+    },
+  );
+
+  ctx.ui.setWidget(
+    "powerline-secondary",
+    (_tui: any, theme: Theme) => ({
+      dispose() {},
+      invalidate() {
+        resetLayoutCache(rt);
+      },
+      render(width: number): string[] {
+        return renderPowerlineSecondaryLines(rt, width, theme);
+      },
+    }),
+    { placement: "belowEditor" },
+  );
+
+  ctx.ui.setWidget(
+    "powerline-bash-transcript",
+    (_tui: any, theme: Theme) => ({
+      dispose() {},
+      invalidate() {},
+      render(width: number): string[] {
+        return renderBashTranscriptLines(rt, width, theme);
+      },
+    }),
+    { placement: "belowEditor" },
+  );
+
+  ctx.ui.setWidget(
+    "powerline-queue-preview",
+    (_tui: any, theme: Theme) => ({
+      dispose() {},
+      invalidate() {},
+      render(width: number): string[] {
+        return renderPowerlineQueuePreviewLines(rt, width, theme);
+      },
+    }),
+    { placement: "belowEditor" },
+  );
+
+  ctx.ui.setWidget(
+    "powerline-last-prompt",
+    () => ({
+      dispose() {},
+      invalidate() {},
+      render(width: number): string[] {
+        return renderLastPromptLines(rt, width);
+      },
+    }),
+    { placement: "belowEditor" },
+  );
+}

package/src/extension/prompt-history.ts

@@ -0,0 +1,219 @@
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { getAgentPath } from "../paths/agent-dirs.ts";
+import { isRecord } from "./settings-io.ts";
+import { PROMPT_HISTORY_LIMIT } from "./constants.ts";
+
+const PROMPT_HISTORY_TRACKED = Symbol.for("powerlinePromptHistoryTracked");
+const PROMPT_HISTORY_STATE_KEY = Symbol.for("powerlinePromptHistoryState");
+
+export interface PromptHistoryEditor {
+  addToHistory?: (text: string) => void;
+}
+
+export type PromptHistoryState = { savedPromptHistory: string[] };
+
+export function hasNonWhitespaceText(text: string): boolean {
+  return text.trim().length > 0;
+}
+
+export function isPromptHistoryState(
+  value: unknown,
+): value is PromptHistoryState {
+  return (
+    isRecord(value) &&
+    Array.isArray(value.savedPromptHistory) &&
+    value.savedPromptHistory.every((entry) => typeof entry === "string")
+  );
+}
+
+export function getPromptHistoryState(): PromptHistoryState {
+  const existing = Reflect.get(globalThis, PROMPT_HISTORY_STATE_KEY);
+  if (isPromptHistoryState(existing)) {
+    return existing;
+  }
+
+  const state: PromptHistoryState = { savedPromptHistory: [] };
+  Reflect.set(globalThis, PROMPT_HISTORY_STATE_KEY, state);
+  return state;
+}
+
+export function readPromptHistory(
+  editor: PromptHistoryEditor | null | undefined,
+): string[] {
+  if (!editor) return [];
+  const history = Reflect.get(editor, "history");
+  if (!Array.isArray(history)) return [];
+
+  const normalized: string[] = [];
+  for (const entry of history) {
+    if (typeof entry !== "string") continue;
+    const trimmed = entry.trim();
+    if (!trimmed) continue;
+    if (normalized.length > 0 && normalized[normalized.length - 1] === trimmed)
+      continue;
+    normalized.push(trimmed);
+    if (normalized.length >= PROMPT_HISTORY_LIMIT) break;
+  }
+
+  return normalized;
+}
+
+export function snapshotPromptHistory(
+  editor: PromptHistoryEditor | null | undefined,
+): void {
+  const history = readPromptHistory(editor);
+  if (history.length > 0) {
+    getPromptHistoryState().savedPromptHistory = [...history];
+  }
+}
+
+export function restorePromptHistory(
+  editor: PromptHistoryEditor | null | undefined,
+): void {
+  const { savedPromptHistory } = getPromptHistoryState();
+  if (!savedPromptHistory.length || typeof editor?.addToHistory !== "function")
+    return;
+
+  for (let i = savedPromptHistory.length - 1; i >= 0; i--) {
+    editor.addToHistory(savedPromptHistory[i]);
+  }
+}
+
+export function trackPromptHistory(
+  editor: PromptHistoryEditor | null | undefined,
+): void {
+  if (!editor || typeof editor.addToHistory !== "function") return;
+  if (Reflect.get(editor, PROMPT_HISTORY_TRACKED)) {
+    snapshotPromptHistory(editor);
+    return;
+  }
+
+  const originalAddToHistory = editor.addToHistory.bind(editor);
+  editor.addToHistory = (text: string) => {
+    originalAddToHistory(text);
+    snapshotPromptHistory(editor);
+  };
+  Reflect.set(editor, PROMPT_HISTORY_TRACKED, true);
+  snapshotPromptHistory(editor);
+}
+
+function getSessionsPath(): string {
+  return getAgentPath("sessions");
+}
+
+function getProjectSessionsPath(cwd: string): string {
+  const projectKey = cwd
+    .replace(/^[/\\]+|[/\\]+$/g, "")
+    .replace(/[\\/]+/g, "-");
+
+  return join(getSessionsPath(), `--${projectKey}--`);
+}
+
+export function getPromptHistoryText(content: unknown): string {
+  if (typeof content === "string") {
+    return content.replace(/\s+/g, " ").trim();
+  }
+
+  if (!Array.isArray(content)) {
+    return "";
+  }
+
+  const parts: string[] = [];
+  for (const block of content) {
+    if (
+      !isRecord(block) ||
+      block.type !== "text" ||
+      typeof block.text !== "string"
+    ) {
+      continue;
+    }
+    parts.push(block.text);
+  }
+
+  return parts.join("\n").replace(/\s+/g, " ").trim();
+}
+
+export function readRecentProjectPrompts(cwd: string, limit: number): string[] {
+  const sessionsPath = getProjectSessionsPath(cwd);
+  if (!existsSync(sessionsPath)) {
+    return [];
+  }
+
+  const promptEntries: { text: string; timestamp: number }[] = [];
+  const fileNames = readdirSync(sessionsPath).filter((fileName) =>
+    fileName.endsWith(".jsonl"),
+  );
+
+  for (const fileName of fileNames) {
+    const filePath = join(sessionsPath, fileName);
+    const lines = readFileSync(filePath, "utf-8").split("\n");
+
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (
+        !line ||
+        !line.includes('"type":"message"') ||
+        !line.includes('"role":"user"')
+      ) {
+        continue;
+      }
+
+      let entry: unknown;
+      try {
+        entry = JSON.parse(line);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `Failed to parse session file ${filePath}: ${message}`,
+          { cause: error },
+        );
+      }
+
+      if (
+        !isRecord(entry) ||
+        entry.type !== "message" ||
+        !isRecord(entry.message) ||
+        entry.message.role !== "user"
+      ) {
+        continue;
+      }
+
+      const text = getPromptHistoryText(entry.message.content);
+      if (!hasNonWhitespaceText(text)) {
+        continue;
+      }
+
+      const timestamp =
+        typeof entry.message.timestamp === "number"
+          ? entry.message.timestamp
+          : typeof entry.timestamp === "string"
+            ? Date.parse(entry.timestamp)
+            : 0;
+
+      promptEntries.push({
+        text,
+        timestamp: Number.isFinite(timestamp) ? timestamp : 0,
+      });
+    }
+  }
+
+  promptEntries.sort((a, b) => b.timestamp - a.timestamp);
+
+  const prompts: string[] = [];
+  const seen = new Set<string>();
+  for (const entry of promptEntries) {
+    if (seen.has(entry.text)) {
+      continue;
+    }
+
+    seen.add(entry.text);
+    prompts.push(entry.text);
+    if (prompts.length >= limit) {
+      return prompts;
+    }
+  }
+
+  return prompts;
+}