@groeponline/pi-wishcraft 0.17.3

package/src/extension/settings-io.ts

@@ -0,0 +1,202 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+import type { StatusLinePreset } from "../config/types.ts";
+import type { PowerlineConfig } from "../config/powerline-config.ts";
+import {
+  nextPowerlineSettingWithOptions,
+  nextPowerlineSettingWithPreset,
+} from "../config/powerline-config.ts";
+import { getAgentPath } from "../paths/agent-dirs.ts";
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function getSettingsPath(): string {
+  return getAgentPath("settings.json");
+}
+
+export function getProjectSettingsPath(cwd: string): string {
+  return join(cwd, ".pi", "settings.json");
+}
+
+export function getGlobalCompactionPolicyPath(): string {
+  return getAgentPath("compaction-policy.json");
+}
+
+export function getCustomCompactionExtensionPath(): string {
+  return getAgentPath("extensions", "pi-custom-compaction");
+}
+
+export function mergeSettings(
+  base: Record<string, unknown>,
+  override: Record<string, unknown>,
+): Record<string, unknown> {
+  const merged: Record<string, unknown> = { ...base };
+
+  for (const [key, overrideValue] of Object.entries(override)) {
+    const baseValue = merged[key];
+    merged[key] =
+      isRecord(baseValue) && isRecord(overrideValue)
+        ? mergeSettings(baseValue, overrideValue)
+        : overrideValue;
+  }
+
+  return merged;
+}
+
+export function readSettingsFile(
+  settingsPath: string,
+): Record<string, unknown> {
+  try {
+    if (!existsSync(settingsPath)) {
+      return {};
+    }
+
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (!isRecord(parsed)) {
+      console.debug(
+        `[powerline-footer] Ignoring non-object settings at ${settingsPath}`,
+      );
+      return {};
+    }
+
+    return parsed;
+  } catch (error) {
+    // Settings are user-edited input. Log and keep the extension running with defaults
+    // instead of crashing the UI during startup.
+    console.debug(
+      `[powerline-footer] Failed to read settings from ${settingsPath}:`,
+      error,
+    );
+    return {};
+  }
+}
+
+export function readWritableSettingsFile(
+  settingsPath: string,
+): Record<string, unknown> | null {
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (!isRecord(parsed)) {
+      console.debug(
+        `[powerline-footer] Refusing to write settings to non-object file at ${settingsPath}`,
+      );
+      return null;
+    }
+
+    return parsed;
+  } catch (error) {
+    // Do not overwrite malformed user settings with partial data. Surface the failure
+    // through the command handler so the user can fix the file intentionally.
+    console.debug(
+      `[powerline-footer] Failed to parse settings at ${settingsPath}:`,
+      error,
+    );
+    return null;
+  }
+}
+
+export function readCompactionPolicyEnabled(
+  configPath: string,
+): boolean | undefined {
+  if (!existsSync(configPath)) return undefined;
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (!isRecord(parsed) || typeof parsed.enabled !== "boolean") return false;
+    return parsed.enabled;
+  } catch (error) {
+    console.debug(
+      `[powerline-footer] Failed to read compaction policy from ${configPath}:`,
+      error,
+    );
+    return false;
+  }
+}
+
+export function detectCustomCompactionEnabled(cwd: string): boolean {
+  if (!existsSync(getCustomCompactionExtensionPath())) return false;
+
+  const projectSetting = readCompactionPolicyEnabled(
+    join(cwd, ".pi", "compaction-policy.json"),
+  );
+  if (projectSetting !== undefined) return projectSetting;
+
+  return readCompactionPolicyEnabled(getGlobalCompactionPolicyPath()) ?? false;
+}
+
+export function readSettings(
+  cwd: string = process.cwd(),
+): Record<string, unknown> {
+  return mergeSettings(
+    readSettingsFile(getSettingsPath()),
+    readSettingsFile(getProjectSettingsPath(cwd)),
+  );
+}
+
+export function writePowerlineSetting(
+  cwd: string,
+  update: (existingPowerlineSetting: unknown) => unknown,
+): boolean {
+  const globalSettingsPath = getSettingsPath();
+  const projectSettingsPath = getProjectSettingsPath(cwd);
+  const globalSettings = readWritableSettingsFile(globalSettingsPath);
+  const projectSettings = readWritableSettingsFile(projectSettingsPath);
+
+  if (globalSettings === null || projectSettings === null) {
+    return false;
+  }
+
+  const writeToProject = Object.prototype.hasOwnProperty.call(
+    projectSettings,
+    "powerline",
+  );
+  const settingsPath = writeToProject
+    ? projectSettingsPath
+    : globalSettingsPath;
+  const settings = writeToProject ? projectSettings : globalSettings;
+
+  settings.powerline = update(settings.powerline);
+
+  try {
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.debug(
+      `[powerline-footer] Failed to persist powerline setting to ${settingsPath}:`,
+      error,
+    );
+    return false;
+  }
+}
+
+export function writePowerlinePresetSetting(
+  preset: StatusLinePreset,
+  cwd: string = process.cwd(),
+): boolean {
+  return writePowerlineSetting(cwd, (existingPowerlineSetting) =>
+    nextPowerlineSettingWithPreset(existingPowerlineSetting, preset),
+  );
+}
+
+export function writePowerlineOptionSetting(
+  cwd: string,
+  updates: Partial<
+    Pick<PowerlineConfig, "welcome" | "stashSharpSShortcut" | "placement">
+  >,
+  currentPreset: StatusLinePreset,
+): boolean {
+  return writePowerlineSetting(cwd, (existingPowerlineSetting) =>
+    nextPowerlineSettingWithOptions(
+      existingPowerlineSetting,
+      updates,
+      currentPreset,
+    ),
+  );
+}

package/src/extension/shortcuts-config.ts

@@ -0,0 +1,357 @@
+import { TUI_KEYBINDINGS } from "@earendil-works/pi-tui";
+
+import type { BashModeSettings } from "../../bash-mode/types.ts";
+import {
+  isSupportedSuperShortcut,
+  shortcutConflictKey,
+  shortcutUsesSuper,
+} from "../shortcuts/matching.ts";
+import { isRecord } from "./settings-io.ts";
+import {
+  DEFAULT_BASH_MODE_SETTINGS,
+  DEFAULT_SHORTCUTS,
+  SHORTCUT_KEYS,
+} from "./constants.ts";
+import type {
+  PowerlineShortcutKey,
+  PowerlineShortcuts,
+  ShortcutBinding,
+} from "./types.ts";
+
+const APP_RESERVED_SHORTCUTS = [
+  "escape",
+  "ctrl+c",
+  "ctrl+d",
+  "ctrl+z",
+  "shift+tab",
+  "ctrl+p",
+  "shift+ctrl+p",
+  "ctrl+l",
+  "ctrl+o",
+  "shift+ctrl+o",
+  "ctrl+t",
+  "ctrl+n",
+  "ctrl+g",
+  "alt+enter",
+  "alt+up",
+  "alt+down",
+  "ctrl+v",
+  "alt+v",
+  "shift+l",
+  "shift+t",
+  "ctrl+s",
+  "ctrl+r",
+  "ctrl+backspace",
+  "ctrl+a",
+  "ctrl+x",
+  "ctrl+u",
+] as const;
+const EXTRA_RESERVED_SHORTCUTS = ["alt+s"] as const;
+const SHORTCUT_MODIFIER_ORDER = ["ctrl", "alt", "super", "shift"] as const;
+const SHORTCUT_MODIFIERS = new Set<string>(SHORTCUT_MODIFIER_ORDER);
+const SHORTCUT_NAMED_KEYS = new Set([
+  "escape",
+  "esc",
+  "enter",
+  "return",
+  "tab",
+  "space",
+  "backspace",
+  "delete",
+  "insert",
+  "clear",
+  "home",
+  "end",
+  "pageup",
+  "pagedown",
+  "up",
+  "down",
+  "left",
+  "right",
+]);
+const SHORTCUT_SYMBOL_KEYS = new Set([
+  "`",
+  "-",
+  "=",
+  "[",
+  "]",
+  "\\",
+  ";",
+  "'",
+  ",",
+  ".",
+  "/",
+  "!",
+  "@",
+  "#",
+  "$",
+  "%",
+  "^",
+  "&",
+  "*",
+  "(",
+  ")",
+  "_",
+  "|",
+  "~",
+  "{",
+  "}",
+  ":",
+  "<",
+  ">",
+  "?",
+]);
+
+export function normalizeShortcut(value: string): string {
+  const parts = value.trim().toLowerCase().split("+");
+  if (parts.length <= 1) return parts[0] ?? "";
+
+  const modifierRank = new Map<string, number>(
+    SHORTCUT_MODIFIER_ORDER.map((modifier, index) => [modifier, index]),
+  );
+  const modifiers = parts
+    .slice(0, -1)
+    .sort((a, b) => (modifierRank.get(a) ?? 99) - (modifierRank.get(b) ?? 99));
+  return [...modifiers, parts[parts.length - 1]].join("+");
+}
+
+export function reservedShortcuts(): Set<string> {
+  const shortcuts = new Set<string>(
+    [...EXTRA_RESERVED_SHORTCUTS, ...APP_RESERVED_SHORTCUTS].map(
+      normalizeShortcut,
+    ),
+  );
+
+  for (const definition of Object.values(TUI_KEYBINDINGS)) {
+    const defaultKeys = definition.defaultKeys;
+    const keys =
+      defaultKeys === undefined
+        ? []
+        : Array.isArray(defaultKeys)
+          ? defaultKeys
+          : [defaultKeys];
+    for (const key of keys) {
+      shortcuts.add(normalizeShortcut(key));
+    }
+  }
+
+  return shortcuts;
+}
+
+export function isValidShortcutKeyPart(keyPart: string): boolean {
+  const lowerKeyPart = keyPart.toLowerCase();
+
+  if (/^[a-z0-9]$/i.test(keyPart)) return true;
+  if (/^f([1-9]|1[0-2])$/i.test(keyPart)) return true;
+  if (SHORTCUT_NAMED_KEYS.has(lowerKeyPart)) return true;
+
+  return SHORTCUT_SYMBOL_KEYS.has(keyPart);
+}
+
+export function parseShortcutOverride(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed || /\s/.test(trimmed)) {
+    return null;
+  }
+
+  const parts = trimmed.split("+");
+  if (parts.some((part) => part.length === 0)) {
+    return null;
+  }
+
+  const modifierParts = parts.slice(0, -1).map((part) => {
+    const modifier = part.toLowerCase();
+    return modifier === "cmd" || modifier === "command" ? "super" : modifier;
+  });
+  if (new Set(modifierParts).size !== modifierParts.length) {
+    return null;
+  }
+
+  for (const modifier of modifierParts) {
+    if (!SHORTCUT_MODIFIERS.has(modifier)) {
+      return null;
+    }
+  }
+
+  const keyPart = parts[parts.length - 1];
+  if (!isValidShortcutKeyPart(keyPart)) {
+    return null;
+  }
+
+  const normalizedKey = SHORTCUT_SYMBOL_KEYS.has(keyPart)
+    ? keyPart
+    : keyPart.toLowerCase();
+  const normalizedShortcut = normalizeShortcut(
+    [...modifierParts, normalizedKey].join("+"),
+  );
+  if (
+    shortcutUsesSuper(normalizedShortcut) &&
+    !isSupportedSuperShortcut(normalizedShortcut)
+  ) {
+    return null;
+  }
+
+  return normalizedShortcut;
+}
+
+export function shortcutUsageKey(shortcut: string): string {
+  return shortcutConflictKey(normalizeShortcut(shortcut));
+}
+
+export function parseShortcutSetting(
+  value: unknown,
+): ShortcutBinding | undefined {
+  if (value === null || value === undefined) return null;
+  if (typeof value === "string" && value.trim() === "") return null;
+  return parseShortcutOverride(value) ?? undefined;
+}
+
+export function findShortcutReplacement(
+  key: PowerlineShortcutKey,
+  used: Set<string>,
+): string | null {
+  const preferred = DEFAULT_SHORTCUTS[key];
+  if (preferred && !used.has(shortcutUsageKey(preferred))) {
+    return preferred;
+  }
+
+  for (const shortcutKey of SHORTCUT_KEYS) {
+    const candidate = DEFAULT_SHORTCUTS[shortcutKey];
+    if (candidate && !used.has(shortcutUsageKey(candidate))) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+export function bashToggleShortcutReservation(
+  settings: Record<string, unknown>,
+): ShortcutBinding {
+  const raw = isRecord(settings.bashMode) ? settings.bashMode : {};
+  if (!Object.prototype.hasOwnProperty.call(raw, "toggleShortcut")) {
+    return DEFAULT_BASH_MODE_SETTINGS.toggleShortcut;
+  }
+
+  const parsed = parseShortcutSetting(raw.toggleShortcut);
+  return parsed === undefined
+    ? DEFAULT_BASH_MODE_SETTINGS.toggleShortcut
+    : parsed;
+}
+
+export function resolveShortcutConfig(
+  settings: Record<string, unknown>,
+): PowerlineShortcuts {
+  const resolved: PowerlineShortcuts = { ...DEFAULT_SHORTCUTS };
+  const shortcutSettings = settings.powerlineShortcuts;
+
+  if (isRecord(shortcutSettings)) {
+    for (const key of SHORTCUT_KEYS) {
+      if (!Object.prototype.hasOwnProperty.call(shortcutSettings, key)) {
+        continue;
+      }
+
+      const override = parseShortcutSetting(shortcutSettings[key]);
+      if (override !== undefined) {
+        resolved[key] = override;
+      }
+    }
+  }
+
+  const used = new Set(Array.from(reservedShortcuts(), shortcutUsageKey));
+  const reservedBashToggle = bashToggleShortcutReservation(settings);
+  if (reservedBashToggle) {
+    used.add(shortcutUsageKey(reservedBashToggle));
+  }
+
+  for (const key of SHORTCUT_KEYS) {
+    const configured = resolved[key];
+    if (configured === null) {
+      continue;
+    }
+
+    const configuredUsageKey = shortcutUsageKey(configured);
+
+    if (!used.has(configuredUsageKey)) {
+      used.add(configuredUsageKey);
+      continue;
+    }
+
+    const replacement = findShortcutReplacement(key, used);
+    if (!replacement) {
+      console.debug(
+        `[powerline-footer] Shortcut conflict for ${key}: "${configured}" is already in use`,
+      );
+      continue;
+    }
+
+    console.debug(
+      `[powerline-footer] Shortcut conflict for ${key}: "${configured}" replaced with "${replacement}"`,
+    );
+
+    resolved[key] = replacement;
+    used.add(shortcutUsageKey(replacement));
+  }
+
+  return resolved;
+}
+
+export function parseBashModeSettings(
+  settings: Record<string, unknown>,
+  powerlineShortcuts?: PowerlineShortcuts,
+): BashModeSettings {
+  const raw = isRecord(settings.bashMode) ? settings.bashMode : {};
+  const used = new Set(Array.from(reservedShortcuts(), shortcutUsageKey));
+  if (powerlineShortcuts) {
+    for (const shortcut of Object.values(powerlineShortcuts)) {
+      if (shortcut) {
+        used.add(shortcutUsageKey(shortcut));
+      }
+    }
+  }
+
+  const configuredToggleShortcut = Object.prototype.hasOwnProperty.call(
+    raw,
+    "toggleShortcut",
+  )
+    ? parseShortcutSetting(raw.toggleShortcut)
+    : undefined;
+  const fallbackToggleShortcut = used.has(
+    shortcutUsageKey(DEFAULT_BASH_MODE_SETTINGS.toggleShortcut),
+  )
+    ? null
+    : DEFAULT_BASH_MODE_SETTINGS.toggleShortcut;
+  const toggleShortcut =
+    configuredToggleShortcut === null
+      ? null
+      : configuredToggleShortcut &&
+          !used.has(shortcutUsageKey(configuredToggleShortcut))
+        ? configuredToggleShortcut
+        : fallbackToggleShortcut;
+
+  if (configuredToggleShortcut && toggleShortcut !== configuredToggleShortcut) {
+    console.debug(
+      `[powerline-footer] Bash mode shortcut conflict: "${configuredToggleShortcut}" replaced with "${toggleShortcut ?? "disabled"}"`,
+    );
+  }
+  const transcriptMaxLines =
+    typeof raw.transcriptMaxLines === "number" &&
+    Number.isFinite(raw.transcriptMaxLines)
+      ? Math.max(100, Math.floor(raw.transcriptMaxLines))
+      : DEFAULT_BASH_MODE_SETTINGS.transcriptMaxLines;
+  const transcriptMaxBytes =
+    typeof raw.transcriptMaxBytes === "number" &&
+    Number.isFinite(raw.transcriptMaxBytes)
+      ? Math.max(16 * 1024, Math.floor(raw.transcriptMaxBytes))
+      : DEFAULT_BASH_MODE_SETTINGS.transcriptMaxBytes;
+
+  return {
+    toggleShortcut,
+    transcriptMaxLines,
+    transcriptMaxBytes,
+  };
+}