@groeponline/pi-wishcraft 0.17.3

package/src/extension/bash-mode-actions.ts

@@ -0,0 +1,104 @@
+import {
+  appendProjectHistory,
+  matchHistoryEntries,
+  readGlobalShellHistory,
+  readProjectHistory,
+} from "../../bash-mode/history.ts";
+import { ManagedShellSession } from "../../bash-mode/shell-session.ts";
+import { requestStatusRender } from "./segment-context.ts";
+import type { RuntimeState } from "./types.ts";
+
+export const getShellPath = () => process.env.SHELL || "/bin/sh";
+
+export const getShellCwd = (rt: RuntimeState) =>
+  rt.shellSession?.state.cwd ?? rt.currentCtx?.cwd ?? process.cwd();
+
+export const getShellHistoryEntries = (
+  rt: RuntimeState,
+  prefix: string,
+): string[] => {
+  const project = matchHistoryEntries(
+    readProjectHistory(rt.currentCtx?.cwd ?? process.cwd()).map(
+      (entry) => entry.command,
+    ),
+    prefix,
+    50,
+  );
+  const global = matchHistoryEntries(
+    readGlobalShellHistory(getShellPath()),
+    prefix,
+    50,
+  );
+  return [...new Set([...project, ...global])];
+};
+
+export const ensureShellSession = async (
+  rt: RuntimeState,
+): Promise<ManagedShellSession> => {
+  if (!rt.shellSession) {
+    rt.shellSession = new ManagedShellSession(
+      getShellPath(),
+      rt.currentCtx?.cwd ?? process.cwd(),
+      rt.bashTranscript,
+      () => requestStatusRender(rt),
+      (command, cwd) =>
+        appendProjectHistory(rt.currentCtx?.cwd ?? process.cwd(), command, cwd),
+    );
+  }
+  await rt.shellSession.ensureReady();
+  return rt.shellSession;
+};
+
+export const runShellCommand = async (
+  rt: RuntimeState,
+  command: string,
+  ctx: any,
+): Promise<void> => {
+  try {
+    const session = await ensureShellSession(rt);
+    await session.runCommand(command);
+    requestStatusRender(rt);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Failed to run shell command: ${message}`, "error");
+  }
+};
+
+export const setBashModeActive = async (
+  rt: RuntimeState,
+  value: boolean,
+  ctx: any,
+): Promise<void> => {
+  if (value === rt.bashModeActive) return;
+  if (!value && rt.shellSession?.state.running) {
+    ctx.ui.notify(
+      "Wait for the current shell command to finish before leaving bash mode",
+      "warning",
+    );
+    return;
+  }
+
+  if (value) {
+    try {
+      const session = await ensureShellSession(rt);
+      rt.bashModeActive = true;
+      rt.currentEditor?.dismissBashModeUi?.();
+      rt.currentEditor?.refreshGhostSuggestion?.();
+      requestStatusRender(rt);
+      ctx.ui.notify(`Bash mode enabled (${session.state.shellName})`, "info");
+    } catch (error) {
+      rt.shellSession?.dispose();
+      rt.shellSession = null;
+      rt.bashModeActive = false;
+      requestStatusRender(rt);
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`Failed to start shell session: ${message}`, "error");
+    }
+    return;
+  }
+
+  rt.bashModeActive = value;
+  rt.currentEditor?.dismissBashModeUi?.();
+  requestStatusRender(rt);
+  ctx.ui.notify("Bash mode disabled", "info");
+};

package/src/extension/commands.ts

@@ -0,0 +1,268 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type KeyId, type SelectItem } from "@earendil-works/pi-tui";
+import { execSync } from "node:child_process";
+
+import type { StatusLinePreset } from "../config/types.ts";
+import { PRESETS } from "../config/presets.ts";
+import { registerCdCommand } from "../shell/cd-command.ts";
+import { registerVibeCommand } from "./vibe-command.ts";
+import { registerQueueCommands } from "./queue-commands.ts";
+import {
+  writePowerlineOptionSetting,
+  writePowerlinePresetSetting,
+} from "./settings-io.ts";
+import {
+  showOpenPortsList,
+  showPowerlineMainMenu,
+  showSelectOverlay,
+} from "./menu-views.ts";
+import { openStashHistory } from "./shortcuts-router.ts";
+import { ensureShellSession, setBashModeActive } from "./bash-mode-actions.ts";
+import { setupCustomEditor } from "./custom-editor.ts";
+import { getPromptHistoryState } from "./prompt-history.ts";
+import { requestStatusRender, resetLayoutCache } from "./segment-context.ts";
+import { config, normalizePreset } from "./state.ts";
+import type { RuntimeState } from "./types.ts";
+
+export function registerCommands(pi: ExtensionAPI, rt: RuntimeState): void {
+  registerCdCommand(pi, () => rt.currentCtx?.cwd ?? process.cwd());
+  registerVibeCommand(pi);
+  registerQueueCommands(pi, rt);
+
+  // Command to toggle/configure
+  pi.registerCommand("powerline", {
+    description: "Configure powerline status (toggle, preset)",
+    handler: async (args, ctx) => {
+      // Update context reference (command ctx may have more methods)
+      rt.currentCtx = ctx;
+
+      if (!args?.trim()) {
+        // Toggle
+        rt.enabled = !rt.enabled;
+        if (rt.enabled) {
+          setupCustomEditor(pi, rt, ctx);
+          ctx.ui.notify("Powerline enabled", "info");
+        } else {
+          rt.shellSession?.dispose();
+          rt.shellSession = null;
+          rt.bashTranscript.clear();
+          rt.bashModeActive = false;
+          rt.dismissWelcomeOverlay?.();
+          rt.dismissWelcomeOverlay = null;
+          rt.welcomeHeaderActive = false;
+          rt.welcomeOverlayShouldDismiss = false;
+          rt.welcomeDismissScheduler.cancel();
+          getPromptHistoryState().savedPromptHistory = [];
+          rt.stashedEditorText = null;
+          ctx.ui.setStatus("stash", undefined);
+          rt.restoreFooterStatusRepaintHook?.();
+          rt.restoreFooterStatusRepaintHook = null;
+          rt.stashShortcutInputUnsubscribe?.();
+          rt.stashShortcutInputUnsubscribe = null;
+          // Clear all custom UI components
+          ctx.ui.setEditorComponent(undefined);
+          ctx.ui.setFooter(undefined);
+          ctx.ui.setHeader(undefined);
+          ctx.ui.setWidget("powerline-top", undefined);
+          ctx.ui.setWidget("powerline-secondary", undefined);
+          ctx.ui.setWidget("powerline-bash-transcript", undefined);
+          ctx.ui.setWidget("powerline-status", undefined);
+          ctx.ui.setWidget("powerline-queue-preview", undefined);
+          ctx.ui.setWidget("powerline-last-prompt", undefined);
+          rt.footerDataRef = null;
+          rt.tuiRef = null;
+          rt.currentEditor = null;
+          rt.statusRenderScheduler.cancel();
+          resetLayoutCache(rt);
+          ctx.ui.notify("Powerline disabled", "info");
+        }
+        return;
+      }
+
+      const normalizedArgs = args.trim().toLowerCase();
+      const placementMatch = /^placement(?:\s+(above|below|toggle))?$/.exec(
+        normalizedArgs,
+      );
+      if (placementMatch) {
+        const requestedPlacement = placementMatch[1];
+        config.placement =
+          requestedPlacement === "above" || requestedPlacement === "below"
+            ? requestedPlacement
+            : config.placement === "above"
+              ? "below"
+              : "above";
+        config.invalidPlacement = null;
+        if (rt.enabled && ctx.hasUI) setupCustomEditor(pi, rt, ctx);
+
+        if (
+          writePowerlineOptionSetting(
+            ctx.cwd,
+            { placement: config.placement },
+            config.preset,
+          )
+        ) {
+          ctx.ui.notify(
+            `Powerline placement set to: ${config.placement}`,
+            "info",
+          );
+        } else {
+          ctx.ui.notify(
+            `Powerline placement set to: ${config.placement} (not persisted; check settings.json)`,
+            "warning",
+          );
+        }
+        return;
+      }
+
+      const preset = normalizePreset(args);
+      if (preset) {
+        config.preset = preset;
+        resetLayoutCache(rt);
+        if (rt.enabled) {
+          setupCustomEditor(pi, rt, ctx);
+        }
+
+        if (writePowerlinePresetSetting(preset, ctx.cwd)) {
+          ctx.ui.notify(`Preset set to: ${preset}`, "info");
+        } else {
+          ctx.ui.notify(
+            `Preset set to: ${preset} (not persisted; check settings.json)`,
+            "warning",
+          );
+        }
+        return;
+      }
+
+      // Show available presets
+      const presetList = Object.keys(PRESETS).join(", ");
+      ctx.ui.notify(`Available presets: ${presetList}`, "info");
+    },
+  });
+
+  pi.registerCommand("stash-history", {
+    description: "Open prompt history picker",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return;
+      if (!rt.enabled) {
+        ctx.ui.notify("Powerline is disabled", "info");
+        return;
+      }
+
+      await openStashHistory(rt, ctx);
+    },
+  });
+
+  pi.registerCommand("bash-mode", {
+    description: "Toggle sticky bash mode (on, off, toggle)",
+    handler: async (args, ctx) => {
+      const mode = args?.trim().toLowerCase() || "toggle";
+      if (mode === "on") {
+        await setBashModeActive(rt, true, ctx);
+        return;
+      }
+      if (mode === "off") {
+        await setBashModeActive(rt, false, ctx);
+        return;
+      }
+      if (mode === "toggle") {
+        await setBashModeActive(rt, !rt.bashModeActive, ctx);
+        return;
+      }
+      ctx.ui.notify("Usage: /bash-mode [on|off|toggle]", "warning");
+    },
+  });
+
+  pi.registerCommand("bash-reset", {
+    description: "Reset the managed bash session",
+    handler: async (_args, ctx) => {
+      rt.shellSession?.dispose();
+      rt.shellSession = null;
+      rt.bashTranscript.clear();
+      if (rt.bashModeActive) {
+        try {
+          await ensureShellSession(rt);
+        } catch (error) {
+          rt.bashModeActive = false;
+          const message =
+            error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Failed to restart shell session: ${message}`, "error");
+          requestStatusRender(rt);
+          return;
+        }
+      }
+      requestStatusRender(rt);
+      ctx.ui.notify("Bash session reset", "info");
+    },
+  });
+
+  pi.registerCommand("tps", {
+    description: "Show or set POWERLINE_TPS value",
+    handler: async (args, ctx) => {
+      rt.currentCtx = ctx;
+      const value = args?.trim();
+      if (!value) {
+        const current = process.env.POWERLINE_TPS || "not set";
+        ctx.ui.notify(`TPS: ${current}`, "info");
+        return;
+      }
+      process.env.POWERLINE_TPS = value;
+      ctx.ui.notify(`TPS set to: ${value}`, "info");
+      rt.tuiRef?.requestRender();
+    },
+  });
+
+  pi.registerCommand("open-ports", {
+    description: "Show open ports",
+    handler: async (_args, ctx) => {
+      rt.currentCtx = ctx;
+      try {
+        const stdout = execSync("ss -tuln", { encoding: "utf8" });
+        const lines = stdout
+          .split("\n")
+          .filter((line) => line.trim().length > 0);
+        const items: SelectItem[] = lines.slice(1).map((line) => ({
+          label: line.trim(),
+          value: line.trim(),
+        }));
+        if (items.length === 0) {
+          ctx.ui.notify("No open ports found", "info");
+          return;
+        }
+        const selected = await showSelectOverlay(
+          ctx,
+          "Open Ports",
+          "Select a port line for details",
+          items,
+          Math.min(items.length, 20),
+        );
+        if (selected) {
+          ctx.ui.notify(`Port: ${selected.value}`, "info");
+        }
+      } catch (error) {
+        ctx.ui.notify(
+          `Failed to list ports: ${error instanceof Error ? error.message : String(error)}`,
+          "error",
+        );
+      }
+    },
+  });
+
+  // Configurable powerline shortcuts (re-bound on /reload via settings.powerlineShortcuts).
+  if (rt.resolvedShortcuts.menu) {
+    pi.registerShortcut(rt.resolvedShortcuts.menu as KeyId, {
+      description: "Powerline menu (navigate / configure / info)",
+      handler: async (ctx) => {
+        await showPowerlineMainMenu(rt, ctx);
+      },
+    });
+  }
+  if (rt.resolvedShortcuts.info) {
+    pi.registerShortcut(rt.resolvedShortcuts.info as KeyId, {
+      description: "Powerline info (full open-ports list)",
+      handler: async (ctx) => {
+        rt.currentCtx = ctx;
+        await showOpenPortsList(ctx);
+      },
+    });
+  }
+}

package/src/extension/constants.ts

@@ -0,0 +1,46 @@
+import type { BashModeSettings } from "../../bash-mode/types.ts";
+import type {
+  PowerlineShortcutKey,
+  PowerlineShortcuts,
+} from "./types.ts";
+
+export const CUSTOM_COMPACTION_STATUS_KEY = "compact-policy";
+
+export const STASH_HISTORY_LIMIT = 12;
+export const PROJECT_PROMPT_HISTORY_LIMIT = 50;
+export const STASH_PREVIEW_WIDTH = 72;
+
+export const DEFAULT_SHORTCUTS: PowerlineShortcuts = {
+  stashHistory: "ctrl+alt+h",
+  copyEditor: "ctrl+alt+c",
+  cutEditor: "ctrl+alt+x",
+  ideaCapture: null,
+  queueOpen: "ctrl+alt+q",
+  editorStart: "super+shift+up",
+  editorEnd: "super+shift+down",
+  menu: "alt+p",
+  info: "alt+i",
+};
+export const DEFAULT_BASH_MODE_SETTINGS = {
+  toggleShortcut: "ctrl+shift+b",
+  transcriptMaxLines: 2000,
+  transcriptMaxBytes: 512 * 1024,
+} as const satisfies BashModeSettings;
+export const SHORTCUT_KEYS: PowerlineShortcutKey[] = [
+  "stashHistory",
+  "copyEditor",
+  "cutEditor",
+  "ideaCapture",
+  "queueOpen",
+  "editorStart",
+  "editorEnd",
+  "menu",
+  "info",
+];
+
+export const PROMPT_HISTORY_LIMIT = 100;
+export const LAYOUT_CACHE_TTL_MS = 250;
+export const STREAMING_LAYOUT_CACHE_TTL_MS = 1000;
+export const STATUS_RENDER_DEBOUNCE_MS = 33;
+export const CONTEXT_STATUS_RENDER_MS = 250;
+export const EDITOR_STATUS_DEFER_MS = 150;