@groeponline/pi-wishcraft 0.17.3

package/src/segments/system.ts

@@ -0,0 +1,235 @@
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import type { StatusLineSegment } from "../config/types.ts";
+import { normalizeCompactExtensionStatus } from "../config/powerline-config.ts";
+import { getIcons, SEP_DOT } from "../theme/icons.ts";
+import { color, withIcon } from "./shared.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Segment Implementations
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const thinkingSegment: StatusLineSegment = {
+  id: "thinking",
+  render(ctx) {
+    const level = ctx.thinkingLevel || "off";
+
+    const levelText: Record<string, string> = {
+      off: "off",
+      minimal: "min",
+      low: "low",
+      medium: "med",
+      high: "high",
+      xhigh: "xhigh",
+    };
+    const label = levelText[level] || level;
+    const content = `think:${label}`;
+
+    if (level === "high" || level === "xhigh" || level === "max") {
+      return { content: color(ctx, "thinking", content), visible: true };
+    }
+
+    if (level === "minimal") {
+      return { content: color(ctx, "thinkingMinimal", content), visible: true };
+    }
+    if (level === "low") {
+      return { content: color(ctx, "thinkingLow", content), visible: true };
+    }
+    if (level === "medium") {
+      return { content: color(ctx, "thinkingMedium", content), visible: true };
+    }
+
+    return { content: color(ctx, "thinking", content), visible: true };
+  },
+};
+
+export const subagentsSegment: StatusLineSegment = {
+  id: "subagents",
+  render() {
+    // Note: pi-mono doesn't have subagent tracking built-in
+    // This would require extension state management
+    // For now, return not visible
+    return { content: "", visible: false };
+  },
+};
+
+export const queueSegment: StatusLineSegment = {
+  id: "queue",
+  render(ctx) {
+    const summary = ctx.queueSummary;
+    const parts: string[] = [];
+
+    if (summary.compacting && summary.queueCount > 0) {
+      parts.push(`compact q ${summary.queueCount}`);
+    } else if (summary.queueCount > 0) {
+      parts.push(`q ${summary.queueCount}`);
+    }
+
+    if (summary.ideaCount > 0) {
+      parts.push(`ideas ${summary.ideaCount}`);
+    }
+
+    if (summary.blockedCount > 0) {
+      parts.push(`blocked ${summary.blockedCount}`);
+    }
+
+    if (parts.length === 0) return { content: "", visible: false };
+    return { content: color(ctx, "queue", parts.join(SEP_DOT)), visible: true };
+  },
+};
+
+export const extensionStatusesSegment: StatusLineSegment = {
+  id: "extension_statuses",
+  render(ctx) {
+    const statuses = ctx.extensionStatuses;
+    if (!statuses || statuses.size === 0)
+      return { content: "", visible: false };
+
+    // Join compact statuses with a separator
+    // Skip: empty strings, notification-style ("[...") shown above editor,
+    // and strings that are only ANSI codes with no visible text.
+    // Also skip statuses explicitly elevated into dedicated custom segments.
+    const parts: string[] = [];
+    for (const [statusKey, value] of statuses.entries()) {
+      if (ctx.hiddenExtensionStatusKeys.has(statusKey)) continue;
+      const normalized = value ? normalizeCompactExtensionStatus(value) : null;
+      if (normalized) {
+        parts.push(normalized);
+      }
+    }
+
+    if (parts.length === 0) return { content: "", visible: false };
+
+    // Statuses already have their own styling applied by the extensions
+    const content = parts.join(` ${SEP_DOT} `);
+    return { content, visible: true };
+  },
+};
+
+export function countListeningPorts(includeUdp = false): number {
+  // ponytail: count UNIQUE TCP listening ports (dedupes IPv4/IPv6 dual-stack and
+  // repeated multicast binds). UDP is noisy (mDNS/DHCP/ephemeral) so it's opt-in.
+  const run = (cmd: string): string | null => {
+    try {
+      return execSync(cmd, { encoding: "utf8" });
+    } catch {
+      return null;
+    }
+  };
+  const proto = includeUdp ? "-tulnH" : "-tlnH";
+  let out = run(`ss ${proto} 2>/dev/null`);
+  if (out === null) out = run(`ss ${proto.replace("H", "")} 2>/dev/null`);
+  if (out === null)
+    out = run(
+      includeUdp ? "netstat -tuln 2>/dev/null" : "netstat -tln 2>/dev/null",
+    );
+  if (out === null) return readProcListeningPorts(includeUdp);
+
+  const lines = out
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean);
+  const start = /^(Proto|Netid|State|Local)/.test(lines[0] ?? "") ? 1 : 0;
+  const ports = new Set<number>();
+  for (const line of lines.slice(start)) {
+    // ss/netstat put the local address at different columns; take the first addr:port token
+    for (const col of line.split(/\s+/)) {
+      const m = /:(\d+)$/.exec(col);
+      if (m) {
+        ports.add(Number(m[1]));
+        break;
+      }
+    }
+  }
+  return ports.size;
+}
+
+function readProcListeningPorts(includeUdp: boolean): number {
+  // ponytail: last-resort /proc parse when ss/netstat are unavailable; dedupe by port
+  const files = includeUdp ? ["tcp", "tcp6", "udp", "udp6"] : ["tcp", "tcp6"];
+  const ports = new Set<number>();
+  for (const f of files) {
+    try {
+      const data = readFileSync(`/proc/net/${f}`, "utf8");
+      for (const line of data.split("\n")) {
+        const cols = line.trim().split(/\s+/);
+        if (cols.length < 4) continue;
+        if (f.startsWith("tcp") && cols[3] !== "0A") continue; // LISTEN state
+        const m = /:([0-9A-Fa-f]{1,4})$/.exec(cols[1]);
+        if (m) ports.add(parseInt(m[1], 16));
+      }
+    } catch {
+      // file may not exist; skip
+    }
+  }
+  return ports.size;
+}
+
+// Rolling 1-second sliding window of (timestamp, cumulative output) samples.
+// Renders fire every ~33ms during streaming, so a per-render delta spikes (tiny dt);
+// a fixed ~1s lookback gives a stable, honest tokens/sec over the last second.
+const tpsSamples: { at: number; output: number }[] = [];
+
+export const tpsSegment: StatusLineSegment = {
+  id: "tps",
+  render(ctx) {
+    const override = process.env.POWERLINE_TPS?.trim();
+    if (override) {
+      return {
+        content: withIcon(getIcons().tps, color(ctx, "tokens", override)),
+        visible: true,
+      };
+    }
+    const out = ctx.usageStats?.output ?? 0;
+    const now = Date.now();
+    tpsSamples.push({ at: now, output: out });
+    // keep the last 5s of samples; drop everything older (idle gaps get forgotten)
+    while (tpsSamples.length > 0 && now - tpsSamples[0].at > 5000)
+      tpsSamples.shift();
+    if (tpsSamples.length > 240) tpsSamples.splice(0, tpsSamples.length - 240);
+
+    // pick the sample closest to 1s old (window [0.5s, 2s]) for a stable rate
+    let ref: { at: number; output: number } | null = null;
+    let bestDelta = Infinity;
+    for (const s of tpsSamples) {
+      const age = now - s.at;
+      if (age < 500) continue;
+      const d = Math.abs(age - 1000);
+      if (d < bestDelta) {
+        bestDelta = d;
+        ref = s;
+      }
+    }
+    let tps = 0;
+    if (ref) {
+      const dt = (now - ref.at) / 1000;
+      const dOut = out - ref.output;
+      if (dt > 0 && dOut >= 0) tps = dOut / dt;
+    }
+    const valueText = tps >= 100 ? Math.round(tps).toString() : tps.toFixed(1);
+    const label = ctx.segmentLabels?.get("tps");
+    const text = label ? `${label} ${valueText}` : valueText;
+    // levendig: light up in the tokens color while generating, dim while idle
+    return {
+      content: withIcon(
+        getIcons().tps,
+        color(ctx, tps > 0 ? "tokens" : "queue", text),
+      ),
+      visible: true,
+    };
+  },
+};
+
+export const openPortsSegment: StatusLineSegment = {
+  id: "open_ports",
+  render(ctx) {
+    const includeUdp = ctx.options?.openPorts?.includeUdp === true;
+    const count = countListeningPorts(includeUdp);
+    const label = ctx.segmentLabels?.get("open_ports");
+    const text = label ? `${label} ${count}` : String(count);
+    return {
+      content: withIcon(getIcons().ports, color(ctx, "queue", text)),
+      visible: true,
+    };
+  },
+};

package/src/segments/usage.ts

@@ -0,0 +1,178 @@
+import type { StatusLineSegment } from "../config/types.ts";
+import { getIcons } from "../theme/icons.ts";
+import { formatUsdCost } from "../usage/rates.ts";
+import { color, withIcon, formatTokens } from "./shared.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Segment Implementations
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const tokenInSegment: StatusLineSegment = {
+  id: "token_in",
+  render(ctx) {
+    const icons = getIcons();
+    const { input } = ctx.usageStats;
+    if (!input) return { content: "", visible: false };
+
+    const content = withIcon(icons.input, formatTokens(input));
+    return { content: color(ctx, "tokens", content), visible: true };
+  },
+};
+
+export const tokenOutSegment: StatusLineSegment = {
+  id: "token_out",
+  render(ctx) {
+    const icons = getIcons();
+    const { output } = ctx.usageStats;
+    if (!output) return { content: "", visible: false };
+
+    const content = withIcon(icons.output, formatTokens(output));
+    return { content: color(ctx, "tokens", content), visible: true };
+  },
+};
+
+export const tokenTotalSegment: StatusLineSegment = {
+  id: "token_total",
+  render(ctx) {
+    const icons = getIcons();
+    const { input, output, cacheRead, cacheWrite } = ctx.usageStats;
+    const total = input + output + cacheRead + cacheWrite;
+    if (!total) return { content: "", visible: false };
+
+    const content = withIcon(icons.tokens, formatTokens(total));
+    return { content: color(ctx, "tokens", content), visible: true };
+  },
+};
+
+export const costSegment: StatusLineSegment = {
+  id: "cost",
+  render(ctx) {
+    const cost = ctx.usageStats.cost + (ctx.usageStats.subagentCost ?? 0);
+    const usingSubscription = ctx.usingSubscription;
+
+    if (!cost && !usingSubscription) {
+      return { content: "", visible: false };
+    }
+
+    const reportedCost =
+      cost > 0 ? formatUsdCost(cost, ctx.options.cost?.currency) : null;
+    if (!usingSubscription) {
+      return reportedCost
+        ? { content: color(ctx, "cost", reportedCost), visible: true }
+        : { content: "", visible: false };
+    }
+
+    const subscriptionDisplay =
+      ctx.options.cost?.subscriptionDisplay ?? "subscription";
+    if (subscriptionDisplay === "reported-cost" && reportedCost) {
+      return { content: color(ctx, "cost", reportedCost), visible: true };
+    }
+    if (subscriptionDisplay === "both" && reportedCost) {
+      return {
+        content: color(ctx, "cost", `${reportedCost} (sub)`),
+        visible: true,
+      };
+    }
+
+    return { content: color(ctx, "cost", "(sub)"), visible: true };
+  },
+};
+
+export const contextPctSegment: StatusLineSegment = {
+  id: "context_pct",
+  render(ctx) {
+    if (ctx.customCompactionEnabled) return { content: "", visible: false };
+
+    const icons = getIcons();
+    const { contextTokens, contextPercent, contextWindow } = ctx;
+    if (!contextWindow || !Number.isFinite(contextPercent)) {
+      return { content: "", visible: false };
+    }
+
+    const autoIcon =
+      ctx.autoCompactEnabled && icons.auto ? ` ${icons.auto}` : "";
+    const percentOnly = ctx.options.context?.format === "percent";
+    // "full" (default): tokens/window + one-decimal percentage + auto-compact icon.
+    // "percent": bare rounded percentage, threshold-colored, no icons.
+    const text = percentOnly
+      ? `${Math.round(contextPercent)}%`
+      : `${formatTokens(contextTokens)}/${formatTokens(contextWindow)} (${contextPercent.toFixed(1)}%)${autoIcon}`;
+
+    // Icon outside color, text inside - use semantic colors for thresholds
+    let content: string;
+    const colored = (semantic: "context" | "contextWarn" | "contextError") =>
+      percentOnly
+        ? color(ctx, semantic, text)
+        : withIcon(icons.context, color(ctx, semantic, text));
+    if (contextPercent > 90) {
+      content = colored("contextError");
+    } else if (contextPercent > 70) {
+      content = colored("contextWarn");
+    } else {
+      content = colored("context");
+    }
+
+    return { content, visible: true };
+  },
+};
+
+export const contextTotalSegment: StatusLineSegment = {
+  id: "context_total",
+  render(ctx) {
+    if (ctx.customCompactionEnabled) return { content: "", visible: false };
+
+    const icons = getIcons();
+    const window = ctx.contextWindow;
+    if (!window) return { content: "", visible: false };
+
+    return {
+      content: color(
+        ctx,
+        "context",
+        withIcon(icons.context, formatTokens(window)),
+      ),
+      visible: true,
+    };
+  },
+};
+
+export const cacheReadSegment: StatusLineSegment = {
+  id: "cache_read",
+  render(ctx) {
+    const icons = getIcons();
+    const { cacheRead, input } = ctx.usageStats;
+    if (!cacheRead) return { content: "", visible: false };
+
+    const format = ctx.options.cache_read?.format ?? "tokens";
+    const hitRate =
+      input + cacheRead > 0
+        ? ((cacheRead / (input + cacheRead)) * 100).toFixed(0)
+        : "0";
+
+    let content: string;
+    if (format === "percent") {
+      content = [icons.cache, `${hitRate}%`].filter(Boolean).join(" ");
+    } else {
+      const tokens = [icons.cache, icons.input, formatTokens(cacheRead)]
+        .filter(Boolean)
+        .join(" ");
+      content = format === "both" ? `${tokens} (${hitRate}%)` : tokens;
+    }
+    return { content: color(ctx, "tokens", content), visible: true };
+  },
+};
+
+export const cacheWriteSegment: StatusLineSegment = {
+  id: "cache_write",
+  render(ctx) {
+    const icons = getIcons();
+    const { cacheWrite } = ctx.usageStats;
+    if (!cacheWrite) return { content: "", visible: false };
+
+    const parts = [icons.cache, icons.output, formatTokens(cacheWrite)].filter(
+      Boolean,
+    );
+    const content = parts.join(" ");
+    return { content: color(ctx, "tokens", content), visible: true };
+  },
+};

package/src/shell/cd-command.ts

@@ -0,0 +1,190 @@
+import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { SessionManager, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+function stripMatchingQuotes(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2) {
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return trimmed.slice(1, -1);
+    }
+  }
+  return trimmed;
+}
+
+function unescapePathArg(value: string): string {
+  return stripMatchingQuotes(value).replace(/\\(.)/g, "$1");
+}
+
+function expandHomePath(value: string, homeDir = homedir()): string {
+  if (value === "~") return homeDir;
+  if (value.startsWith("~/")) return join(homeDir, value.slice(2));
+  return value;
+}
+
+function escapeCompletionPath(value: string): string {
+  return value.replace(/([\\\s"'`$&|;<>()[\]{}?!*])/g, "\\$1");
+}
+
+function displayPath(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+export function resolveCdTarget(args: string, cwd: string, homeDir = homedir()): { path: string } | { error: string } | null {
+  const input = unescapePathArg(args);
+  if (!input) return null;
+
+  const expanded = expandHomePath(input, homeDir);
+  const target = isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+
+  if (!existsSync(target)) {
+    return { error: `Directory does not exist: ${target}` };
+  }
+
+  try {
+    if (!statSync(target).isDirectory()) {
+      return { error: `Not a directory: ${target}` };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { error: `Cannot access directory: ${message}` };
+  }
+
+  return { path: target };
+}
+
+function pathBase(token: string, cwd: string, homeDir: string): { dir: string; prefix: string; displayPrefix: string } {
+  const unescaped = unescapePathArg(token);
+  const expanded = expandHomePath(unescaped, homeDir);
+  const hasSlash = expanded.includes("/");
+
+  if (!hasSlash) {
+    return { dir: cwd, prefix: expanded, displayPrefix: "" };
+  }
+
+  const baseDir = expanded.endsWith("/") ? expanded.slice(0, -1) : dirname(expanded);
+  const dir = isAbsolute(baseDir) ? baseDir : resolve(cwd, baseDir);
+  const prefix = expanded.endsWith("/") ? "" : basename(expanded);
+  const displayPrefix = unescaped.endsWith("/") ? unescaped : unescaped.slice(0, Math.max(0, unescaped.length - prefix.length));
+  return { dir, prefix, displayPrefix };
+}
+
+function isDirectoryEntry(dir: string, name: string): boolean {
+  try {
+    return statSync(join(dir, name)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function getCdArgumentCompletions(argumentPrefix: string, cwd: string, homeDir = homedir()): AutocompleteItem[] {
+  const prefix = argumentPrefix.trimStart();
+  const suggestions: AutocompleteItem[] = [];
+
+  for (const quickPick of ["../", "~/"]) {
+    if (!prefix || quickPick.startsWith(prefix)) {
+      suggestions.push({ value: quickPick, label: quickPick, description: quickPick === "../" ? "Parent directory" : "Home directory" });
+    }
+  }
+
+  const { dir, prefix: entryPrefix, displayPrefix } = pathBase(prefix, cwd, homeDir);
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.name.startsWith(entryPrefix) && (entry.isDirectory() || entry.isSymbolicLink() && isDirectoryEntry(dir, entry.name)))
+      .slice(0, 50)
+      .map((entry) => {
+        const path = displayPath(`${displayPrefix}${entry.name}/`);
+        return {
+          value: escapeCompletionPath(path),
+          label: path,
+        } satisfies AutocompleteItem;
+      });
+
+    suggestions.push(...entries);
+  } catch {
+    return suggestions;
+  }
+
+  const seen = new Set<string>();
+  return suggestions.filter((item) => {
+    if (seen.has(item.value)) return false;
+    seen.add(item.value);
+    return true;
+  });
+}
+
+function removeSessionFile(filePath: string | undefined): void {
+  if (!filePath) return;
+  try {
+    unlinkSync(filePath);
+  } catch {
+    // Best-effort cleanup only; the command still reports the cancellation/error.
+  }
+}
+
+export async function runCdCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const resolved = resolveCdTarget(args, ctx.cwd);
+  if (resolved === null) {
+    ctx.ui.notify(ctx.cwd, "info");
+    return;
+  }
+  if ("error" in resolved) {
+    ctx.ui.notify(resolved.error, "error");
+    return;
+  }
+  if (resolved.path === ctx.cwd) {
+    ctx.ui.notify(`Already in ${ctx.cwd}`, "info");
+    return;
+  }
+
+  const sessionFile = ctx.sessionManager.getSessionFile();
+  if (!sessionFile) {
+    ctx.ui.notify("/cd requires a persisted Pi session", "error");
+    return;
+  }
+
+  await ctx.waitForIdle();
+  const nextSession = SessionManager.forkFrom(sessionFile, resolved.path);
+  const nextSessionFile = nextSession.getSessionFile();
+
+  try {
+    const result = await ctx.switchSession(nextSessionFile!, {
+      withSession: async (nextCtx) => {
+        try {
+          process.chdir(nextCtx.cwd);
+          nextCtx.ui.notify(`Changed directory to ${nextCtx.cwd}`, "info");
+          nextCtx.ui.setTitle(`pi - ${basename(nextCtx.cwd) || nextCtx.cwd}`);
+        } catch (error) {
+          console.debug("[powerline-footer] Failed to update process cwd after /cd:", error);
+        }
+      },
+    });
+    if (result.cancelled) {
+      removeSessionFile(nextSessionFile);
+      ctx.ui.notify("Directory change cancelled", "warning");
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+      ctx.ui.notify(`Failed to change directory: ${message}`, "error");
+    } catch {
+      console.debug("[powerline-footer] Failed to report /cd error:", error);
+    }
+  }
+}
+
+export function registerCdCommand(pi: ExtensionAPI, getCwd: () => string): void {
+  pi.registerCommand("cd", {
+    description: "Switch the Pi session working directory",
+    getArgumentCompletions(argumentPrefix) {
+      return getCdArgumentCompletions(argumentPrefix, getCwd());
+    },
+    handler: runCdCommand,
+  });
+}

package/src/shortcuts/matching.ts

@@ -0,0 +1,61 @@
+import { isKeyRelease, matchesKey, type KeyId } from "@earendil-works/pi-tui";
+
+const SUPER_SHORTCUT_PATTERNS = new Map<string, RegExp>([
+  ["super+up", /^\x1b\[(?:1;9(?::[12])?[AH]|574(?:19|23);9(?::[12])?u|7;9(?::[12])?~|27;9;65~)$/],
+  ["super+down", /^\x1b\[(?:1;9(?::[12])?[BF]|574(?:20|24);9(?::[12])?u|8;9(?::[12])?~|27;9;66~)$/],
+  ["super+home", /^\x1b\[(?:1;9(?::[12])?H|57423;9(?::[12])?u|7;9(?::[12])?~)$/],
+  ["super+end", /^\x1b\[(?:1;9(?::[12])?F|57424;9(?::[12])?u|8;9(?::[12])?~)$/],
+  ["super+pageup", /^\x1b\[(?:5;9(?::[12])?~|57421;9(?::[12])?u)$/],
+  ["super+pagedown", /^\x1b\[(?:6;9(?::[12])?~|57422;9(?::[12])?u)$/],
+  ["super+shift+up", /^\x1b\[(?:1;10(?::[12])?[AH]|574(?:19|23);10(?::[12])?u|7;10(?::[12])?~|27;10;65~)$/],
+  ["super+shift+down", /^\x1b\[(?:1;10(?::[12])?[BF]|574(?:20|24);10(?::[12])?u|8;10(?::[12])?~|27;10;66~)$/],
+  ["super+shift+home", /^\x1b\[(?:1;10(?::[12])?H|57423;10(?::[12])?u|7;10(?::[12])?~)$/],
+  ["super+shift+end", /^\x1b\[(?:1;10(?::[12])?F|57424;10(?::[12])?u|8;10(?::[12])?~)$/],
+]);
+
+export function shortcutUsesSuper(shortcut: string): boolean {
+  const parts = shortcut.toLowerCase().split("+");
+  return parts.slice(0, -1).includes("super");
+}
+
+export function isSupportedSuperShortcut(shortcut: string): boolean {
+  return SUPER_SHORTCUT_PATTERNS.has(shortcut.toLowerCase());
+}
+
+export function shortcutConflictKey(shortcut: string): string {
+  switch (shortcut.toLowerCase()) {
+    case "super+home":
+      return "super+up";
+    case "super+end":
+      return "super+down";
+    case "super+shift+home":
+      return "super+shift+up";
+    case "super+shift+end":
+      return "super+shift+down";
+    default:
+      return shortcut;
+  }
+}
+
+export function matchesConfiguredShortcut(data: string, shortcut: string | null | undefined): boolean {
+  if (!shortcut) return false;
+
+  const normalizedShortcut = shortcut.toLowerCase();
+  if (shortcutUsesSuper(normalizedShortcut)) {
+    return SUPER_SHORTCUT_PATTERNS.get(normalizedShortcut)?.test(data) ?? false;
+  }
+
+  return matchesKey(data, shortcut as KeyId);
+}
+
+export function matchesStashShortcutInput(data: string, options: { includePrintableSharpS?: boolean } = {}): boolean {
+  if (isKeyRelease(data)) return false;
+
+  return (options.includePrintableSharpS === true && data === "ß")
+    || data === "\x1bs"
+    || data === "\x1bS"
+    || /^\x1b\[(?:83|115)(?::\d*)?(?::\d*)?;3(?::\d+)?u$/.test(data)
+    || data === "\x1b[27;3;115~"
+    || data === "\x1b[27;3;83~"
+    || matchesKey(data, "alt+s");
+}