@narumitw/pi-statusline 0.49.2 → 0.49.3

package/dist/chunks/commands-FUT5RTFK.ts

@@ -0,0 +1,774 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension so Pi routes chunks through Jiti.
+import {
+  DEFAULT_STATUSLINE_DOCUMENT,
+  INFORMATION_PROFILES,
+  INFORMATION_PROFILE_NAMES,
+  LINE_BREAK_SEGMENT_NAME,
+  PALETTE_NAMES,
+  PALETTE_PRESET_NAMES,
+  SEGMENT_NAMES,
+  completeStatuslineArguments,
+  inferInformationProfile,
+  removeStatuslineSettingsDocumentIfMatches,
+  saveStatuslineSettingsDocument,
+  segmentPaletteForPreset
+} from "./chunk-6BDIM4OT.js";
+
+// src/commands.ts
+import {
+  DynamicBorder
+} from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Key,
+  matchesKey,
+  SelectList,
+  Text,
+  truncateToWidth,
+  wrapTextWithAnsi
+} from "@earendil-works/pi-tui";
+var EDIT_SETTINGS_LABEL = "Edit settings JSON";
+var SEGMENT_VIEWPORT_SIZE = 6;
+var NARROW_SEGMENT_VIEWPORT_SIZE = 3;
+var SEGMENT_DESCRIPTIONS = {
+  brand: "Pi brand mark",
+  provider: "Current model provider",
+  model: "Current model name",
+  thinking: "Current thinking level",
+  cwd: "Current working directory",
+  branch: "Git branch, status, and linked pull request",
+  tools: "Current tool and streaming activity",
+  context: "Current context-window usage",
+  tokens: "Session token totals",
+  cache: "Prompt-cache reads, writes, and latest hit rate",
+  cost: "Session cost",
+  time: "Current local time",
+  turn: "Current session turn count"
+};
+function registerStatuslineCommand(pi, options) {
+  pi.registerCommand("statusline", {
+    description: "Open or inspect the statusline settings",
+    getArgumentCompletions: completeStatuslineArguments,
+    handler: (args, ctx) => handleStatuslineCommand(args, ctx, options)
+  });
+}
+async function handleStatuslineCommand(args, ctx, options) {
+  const normalized = args.trim();
+  if (!normalized) {
+    await showMainMenu(ctx, options);
+    return;
+  }
+  const tokens = normalized.split(/\s+/u);
+  const subcommand = tokens[0]?.toLowerCase() ?? "";
+  if (tokens.length > 1) {
+    if (canNotify(ctx)) {
+      ctx.ui.notify(`/statusline ${subcommand} does not accept trailing arguments.`, "warning");
+    }
+    return;
+  }
+  switch (subcommand) {
+    case "settings":
+      await editSettings(ctx, options);
+      return;
+    case "status":
+      showStatus(ctx, options);
+      return;
+    case "help":
+      showHelp(ctx, options.settingsPath);
+      return;
+    default:
+      if (canNotify(ctx)) {
+        ctx.ui.notify(`Unknown /statusline subcommand: ${subcommand}`, "warning");
+      }
+  }
+}
+async function showMainMenu(ctx, options) {
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify("/statusline requires an interactive Pi UI in TUI mode.", "error");
+    return;
+  }
+  const fallbackController = new AbortController();
+  const owner = options.getMenuOwner?.() ?? {
+    signal: fallbackController.signal,
+    isCurrent: () => !fallbackController.signal.aborted
+  };
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (owner.signal.aborted || !owner.isCurrent()) return;
+  const menu = defineMenu({
+    start: "main",
+    screens: {
+      main: () => {
+        const config = options.getLoaded().config;
+        return {
+          kind: "actions",
+          title: "pi-statusline",
+          items: [
+            {
+              id: "appearance",
+              label: `Appearance (${config.palettePreset})`,
+              action: "appearance"
+            },
+            {
+              id: "information",
+              label: `Information (${inferInformationProfile(config.segments)})`,
+              to: "information"
+            },
+            { id: "advanced", label: "Advanced", to: "advanced" },
+            { id: "status", label: "Status", action: "status" },
+            { id: "help", label: "Help", action: "help" }
+          ],
+          hint: "close"
+        };
+      },
+      information: () => {
+        const current = inferInformationProfile(options.getLoaded().config.segments);
+        return {
+          kind: "choice",
+          title: "Information level",
+          lines: [`Current profile: ${current}`],
+          items: INFORMATION_PROFILE_NAMES.map((profile) => ({
+            id: profile,
+            label: `${profile[0]?.toUpperCase() ?? ""}${profile.slice(1)}`,
+            description: `${INFORMATION_PROFILES[profile].length} segments`,
+            details: [`Segments: ${INFORMATION_PROFILES[profile].join(" \xB7 ")}`]
+          })),
+          action: "setInformation",
+          currentItemId: current,
+          initialItemId: current === "custom" ? "balanced" : current,
+          hint: "close"
+        };
+      },
+      advanced: () => {
+        const config = options.getLoaded().config;
+        const visibleSegmentCount = config.segments.filter(
+          (segment) => segment !== LINE_BREAK_SEGMENT_NAME
+        ).length;
+        return {
+          kind: "actions",
+          title: "pi-statusline \u2014 Advanced",
+          items: [
+            {
+              id: "layout",
+              label: `Custom layout (${visibleSegmentCount}/${SEGMENT_NAMES.length} shown)`,
+              action: "layout"
+            },
+            { id: "edit", label: EDIT_SETTINGS_LABEL, action: "edit" },
+            { id: "back", label: "Back", action: "back" }
+          ],
+          hint: "back"
+        };
+      }
+    },
+    actions: {
+      appearance: async () => {
+        await choosePalettePreset(ctx, options);
+        return { kind: "close" };
+      },
+      setInformation: async ({ itemId }) => {
+        const profile = INFORMATION_PROFILE_NAMES.find((candidate) => candidate === itemId);
+        if (!profile) return { kind: "rejected" };
+        applyInformationProfile(ctx, options, profile);
+        return { kind: "close" };
+      },
+      layout: async () => {
+        await chooseSegments(ctx, options);
+        return { kind: "close" };
+      },
+      edit: async () => {
+        await editSettings(ctx, options);
+        return { kind: "close" };
+      },
+      status: async () => {
+        showStatus(ctx, options);
+        return { kind: "close" };
+      },
+      help: async () => {
+        showHelp(ctx, options.settingsPath);
+        return { kind: "close" };
+      },
+      back: async () => ({ kind: "back" })
+    }
+  });
+  try {
+    await runMenu(ctx, menu, {
+      getState: () => void 0,
+      signal: owner.signal,
+      isCurrent: owner.isCurrent
+    });
+  } finally {
+    fallbackController.abort(new DOMException("Statusline menu closed", "AbortError"));
+  }
+}
+async function choosePalettePreset(ctx, options) {
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit palettePreset manually: ${options.settingsPath}`, "info");
+    return;
+  }
+  const current = options.getLoaded();
+  let selection;
+  try {
+    selection = await showPalettePresetPicker(ctx, current.config.palettePreset, options);
+  } finally {
+    options.preview?.(void 0, ctx);
+  }
+  if (selection === void 0) return;
+  let loaded;
+  try {
+    const rawDocument = palettePresetDocument(current, selection);
+    loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, rawDocument);
+  } catch (error) {
+    ctx.ui.notify(`Palette preset was not saved: ${formatError(error)}`, "error");
+    return;
+  }
+  try {
+    options.apply(loaded, ctx);
+  } catch (error) {
+    const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
+    ctx.ui.notify(
+      rollbackError ? `Palette preset could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}` : `Palette preset could not be applied: ${formatError(error)}; previous settings restored.`,
+      "error"
+    );
+    return;
+  }
+  const message = loaded.config.palettePreset === "custom" ? "Custom palette applied. Edit colors via /statusline \u2192 Advanced \u2192 Edit settings JSON." : `Palette preset applied: ${loaded.config.palettePreset}.`;
+  ctx.ui.notify(message, "info");
+}
+async function showPalettePresetPicker(ctx, current, options) {
+  const items = PALETTE_PRESET_NAMES.map((palettePreset) => ({
+    value: palettePreset,
+    label: palettePreset,
+    description: [
+      palettePreset === current ? "current" : void 0,
+      palettePreset === "custom" ? "per-segment colors from settings JSON" : void 0
+    ].filter((part) => part !== void 0).join(" \u2022 ") || void 0
+  }));
+  const selectedIndex = PALETTE_PRESET_NAMES.indexOf(current);
+  const result = await ctx.ui.custom((tui, theme, _keybindings, done) => {
+    const container = new Container();
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    const title = new Text("", 1, 0);
+    container.addChild(title);
+    const list = new SelectList(items, Math.min(items.length, 10), {
+      selectedPrefix: (text) => theme.fg("accent", text),
+      selectedText: (text) => theme.fg("accent", text),
+      description: (text) => theme.fg("muted", text),
+      scrollInfo: (text) => theme.fg("dim", text),
+      noMatch: (text) => theme.fg("warning", text)
+    });
+    list.setSelectedIndex(selectedIndex);
+    list.onSelectionChange = (item) => {
+      options.preview?.(item.value, ctx);
+    };
+    list.onSelect = (item) => done(item.value);
+    list.onCancel = () => done(null);
+    container.addChild(list);
+    const hint = new Text("", 1, 0);
+    container.addChild(hint);
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    const updateThemedText = () => {
+      title.setText(theme.fg("accent", theme.bold(`Palette preset (current: ${current})`)));
+      hint.setText(theme.fg("dim", "\u2191\u2193 preview \u2022 enter apply \u2022 esc cancel"));
+    };
+    updateThemedText();
+    return {
+      render: (width) => container.render(width),
+      invalidate() {
+        container.invalidate();
+        updateThemedText();
+      },
+      handleInput(data) {
+        list.handleInput(data);
+        tui.requestRender();
+      }
+    };
+  });
+  return result ?? void 0;
+}
+function applyInformationProfile(ctx, options, selection) {
+  const current = options.getLoaded();
+  try {
+    const change = informationProfileDocument(current, selection);
+    const loaded = applySegmentsDocumentChange(change, ctx, options);
+    ctx.ui.notify(
+      `Information level applied: ${inferInformationProfile(loaded.config.segments)}.`,
+      "info"
+    );
+  } catch (error) {
+    ctx.ui.notify(`Information level was not saved: ${formatError(error)}`, "error");
+  }
+}
+async function chooseSegments(ctx, options) {
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit segments manually: ${options.settingsPath}`, "info");
+    return;
+  }
+  let current = options.getLoaded();
+  let names = segmentMenuOrder(current);
+  let selectedIndex = 0;
+  let moveMode = false;
+  let feedback;
+  await ctx.ui.custom((tui, theme, keybindings, done) => {
+    const commit = (name, change) => {
+      try {
+        current = applySegmentsDocumentChange(change, ctx, options);
+        names = segmentMenuOrder(current);
+        selectedIndex = Math.max(0, names.indexOf(name));
+        feedback = void 0;
+        return true;
+      } catch (error) {
+        ctx.ui.notify(`Statusline segments were not saved: ${formatError(error)}`, "error");
+        return false;
+      }
+    };
+    const toggleSelected = () => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      moveMode = false;
+      commit(name, segmentsDocument(current, name, !current.config.segments.includes(name)));
+    };
+    const toggleLineBreakAfterSelected = () => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      moveMode = false;
+      const segmentIndex = current.config.segments.indexOf(name);
+      if (segmentIndex < 0) {
+        feedback = `Show ${name} before adding a line break.`;
+        return;
+      }
+      const hasLineBreak = current.config.segments[segmentIndex + 1] === LINE_BREAK_SEGMENT_NAME;
+      const hasFollowingSegment = current.config.segments.slice(segmentIndex + 1).some((segment) => segment !== LINE_BREAK_SEGMENT_NAME);
+      if (!hasLineBreak && !hasFollowingSegment) {
+        feedback = `Add another visible segment after ${name} before adding a line break.`;
+        return;
+      }
+      commit(name, lineBreakAfterDocument(current, name));
+    };
+    const reorderSelected = (direction) => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      const visibleNames = visibleSegmentNames(current);
+      const currentIndex = visibleNames.indexOf(name);
+      if (currentIndex < 0) {
+        feedback = `Show ${name} before moving it.`;
+        return;
+      }
+      const targetIndex = currentIndex + direction;
+      if (targetIndex < 0 || targetIndex >= visibleNames.length) {
+        feedback = `${name} is already the ${direction < 0 ? "first" : "last"} visible segment.`;
+        return;
+      }
+      const change = reorderedSegmentsDocument(current, name, direction);
+      if (change) commit(name, change);
+    };
+    const enterMoveMode = () => {
+      const name = names[selectedIndex];
+      if (!name) return;
+      if (!current.config.segments.includes(name)) {
+        feedback = `Show ${name} before moving it.`;
+        return;
+      }
+      moveMode = true;
+      feedback = void 0;
+    };
+    const moveSelection = (offset) => {
+      selectedIndex = Math.max(0, Math.min(names.length - 1, selectedIndex + offset));
+      feedback = void 0;
+    };
+    const renderList = (width) => {
+      const safeWidth = Math.max(1, width);
+      const visibleNames = visibleSegmentNames(current);
+      const visible = new Set(visibleNames);
+      const placements = segmentPlacements(current.config.segments);
+      const viewportSize = safeWidth < 30 ? NARROW_SEGMENT_VIEWPORT_SIZE : SEGMENT_VIEWPORT_SIZE;
+      const startIndex = Math.max(
+        0,
+        Math.min(
+          selectedIndex - Math.floor(viewportSize / 2),
+          Math.max(0, names.length - viewportSize)
+        )
+      );
+      const endIndex = Math.min(names.length, startIndex + viewportSize);
+      const lines = [];
+      let previousSection;
+      for (let index = startIndex; index < endIndex; index += 1) {
+        const name = names[index];
+        if (!name) continue;
+        const section = visible.has(name) ? "visible" : "hidden";
+        if (section !== previousSection) {
+          const heading = section === "visible" ? "Visible \u2014 render order" : "Hidden \u2014 not rendered";
+          lines.push(theme.fg("muted", theme.bold(truncateToWidth(`  ${heading}`, safeWidth))));
+          previousSection = section;
+        }
+        const isSelected = index === selectedIndex;
+        const prefix = isSelected ? "\u2192 " : "  ";
+        const placement = placements.get(name);
+        const lineBreakLabel = hasLineBreakAfter(current.config.segments, name) ? " \xB7 break after" : "";
+        const row = placement ? `${prefix}${`${placement.order}.`.padStart(3)} row ${placement.row} \xB7 ${name.padEnd(8)} \xB7 visible${lineBreakLabel}` : `${prefix}  \xB7 ${name.padEnd(8)} \xB7 hidden`;
+        const truncated = truncateToWidth(row, safeWidth);
+        if (isSelected) lines.push(theme.fg("accent", truncated));
+        else lines.push(section === "visible" ? truncated : theme.fg("muted", truncated));
+      }
+      if (startIndex > 0 || endIndex < names.length) {
+        lines.push(
+          theme.fg(
+            "dim",
+            truncateToWidth(`  (${startIndex + 1}-${endIndex}/${names.length})`, safeWidth)
+          )
+        );
+      }
+      const selected = names[selectedIndex];
+      if (selected) {
+        lines.push("");
+        const detail = feedback ?? SEGMENT_DESCRIPTIONS[selected];
+        const color = feedback ? "warning" : "muted";
+        for (const line of wrapTextWithAnsi(detail, Math.max(1, safeWidth - 2))) {
+          lines.push(theme.fg(color, truncateToWidth(`  ${line}`, safeWidth)));
+        }
+      }
+      lines.push("");
+      const hints = segmentControlHints(safeWidth, moveMode, selected);
+      for (const hint of hints) {
+        lines.push(theme.fg("dim", truncateToWidth(`  ${hint}`, safeWidth)));
+      }
+      return lines;
+    };
+    const container = new Container();
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    const title = new Text("", 1, 0);
+    container.addChild(title);
+    container.addChild({ render: renderList, invalidate() {
+    } });
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    const updateThemedText = () => {
+      title.setText(theme.fg("accent", theme.bold("Statusline segments")));
+    };
+    updateThemedText();
+    return {
+      render: (width) => container.render(width),
+      invalidate() {
+        container.invalidate();
+        updateThemedText();
+      },
+      handleInput(data) {
+        const moveModeKey = matchesKey(data, "m") || matchesKey(data, Key.shift("m"));
+        const lineBreakKey = matchesKey(data, "b") || matchesKey(data, Key.shift("b"));
+        if (matchesKey(data, Key.alt("up"))) {
+          reorderSelected(-1);
+        } else if (matchesKey(data, Key.alt("down"))) {
+          reorderSelected(1);
+        } else if (moveMode) {
+          if (keybindings.matches(data, "tui.select.up")) {
+            reorderSelected(-1);
+          } else if (keybindings.matches(data, "tui.select.down")) {
+            reorderSelected(1);
+          } else if (moveModeKey || keybindings.matches(data, "tui.select.confirm") || data === " " || keybindings.matches(data, "tui.select.cancel")) {
+            moveMode = false;
+            feedback = void 0;
+          }
+        } else if (keybindings.matches(data, "tui.select.up")) {
+          selectedIndex = selectedIndex === 0 ? names.length - 1 : selectedIndex - 1;
+          feedback = void 0;
+        } else if (keybindings.matches(data, "tui.select.down")) {
+          selectedIndex = selectedIndex === names.length - 1 ? 0 : selectedIndex + 1;
+          feedback = void 0;
+        } else if (keybindings.matches(data, "tui.select.pageUp")) {
+          moveSelection(-SEGMENT_VIEWPORT_SIZE);
+        } else if (keybindings.matches(data, "tui.select.pageDown")) {
+          moveSelection(SEGMENT_VIEWPORT_SIZE);
+        } else if (moveModeKey) {
+          enterMoveMode();
+        } else if (lineBreakKey) {
+          toggleLineBreakAfterSelected();
+        } else if (keybindings.matches(data, "tui.select.confirm") || data === " ") {
+          toggleSelected();
+        } else if (keybindings.matches(data, "tui.select.cancel")) {
+          done(void 0);
+        }
+        tui.requestRender();
+      }
+    };
+  });
+}
+async function editSettings(ctx, options) {
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${options.settingsPath}`, "info");
+    return;
+  }
+  const current = options.getLoaded();
+  const edited = await ctx.ui.editor(
+    "pi-statusline.json \u2014 save and close to apply",
+    current.rawDocument ?? DEFAULT_STATUSLINE_DOCUMENT
+  );
+  if (edited === void 0) return;
+  let loaded;
+  try {
+    loaded = (options.save ?? saveStatuslineSettingsDocument)(options.settingsPath, edited);
+  } catch (error) {
+    ctx.ui.notify(`pi-statusline settings were not saved: ${formatError(error)}`, "error");
+    return;
+  }
+  try {
+    options.apply(loaded, ctx);
+  } catch (error) {
+    const rollbackError = restoreStatuslineSettings(ctx, options, current, loaded);
+    ctx.ui.notify(
+      rollbackError ? `pi-statusline settings could not be applied: ${formatError(error)}; rollback failed: ${formatError(rollbackError)}` : `pi-statusline settings could not be applied: ${formatError(error)}; previous settings restored.`,
+      "error"
+    );
+    return;
+  }
+  const suffix = loaded.diagnostics.length > 0 ? ` (${loaded.diagnostics.length} warning${loaded.diagnostics.length === 1 ? "" : "s"})` : "";
+  ctx.ui.notify(`pi-statusline settings saved and applied${suffix}.`, "info");
+}
+function palettePresetDocument(current, palettePreset) {
+  const { parsed } = editableSettings(current, "choosing a palette preset");
+  if (palettePreset === "custom" && !isRecord(parsed.palette)) {
+    const seedPreset = isPaletteName(current.config.palettePreset) ? current.config.palettePreset : "tokyo-night";
+    parsed.palette = segmentPaletteForPreset(seedPreset);
+  } else if (palettePreset !== "custom" && typeof parsed.palette === "string") {
+    delete parsed.palette;
+  }
+  parsed.palettePreset = palettePreset;
+  return `${JSON.stringify(parsed, null, "	")}
+`;
+}
+function informationProfileDocument(current, profile) {
+  const { parsed, rawDocument: previousDocument } = editableSettings(
+    current,
+    "changing information level"
+  );
+  parsed.segments = [...INFORMATION_PROFILES[profile]];
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "	")}
+`,
+    previousDocument
+  };
+}
+function visibleSegmentNames(current) {
+  return current.config.segments.filter(
+    (segment) => segment !== LINE_BREAK_SEGMENT_NAME
+  );
+}
+function segmentMenuOrder(current) {
+  const visible = visibleSegmentNames(current);
+  const visibleSet = new Set(visible);
+  return [...visible, ...SEGMENT_NAMES.filter((name) => !visibleSet.has(name))];
+}
+function hasLineBreakAfter(segments, name) {
+  const index = segments.indexOf(name);
+  return index >= 0 && segments[index + 1] === LINE_BREAK_SEGMENT_NAME;
+}
+function segmentPlacements(segments) {
+  const placements = /* @__PURE__ */ new Map();
+  let order = 0;
+  let row = 1;
+  for (const segment of segments) {
+    if (segment === LINE_BREAK_SEGMENT_NAME) {
+      row += 1;
+      continue;
+    }
+    placements.set(segment, { order: ++order, row });
+  }
+  return placements;
+}
+function segmentControlHints(width, moveMode, selected) {
+  if (moveMode) {
+    return width < 30 ? [
+      `Move mode: ${selected ?? "segment"}`,
+      "\u2191\u2193 move segment",
+      "Enter/Space finish",
+      "Esc leave move mode"
+    ] : [
+      `Move mode \u2014 ${selected ?? "segment"}`,
+      "\u2191\u2193 move \xB7 Enter/Space finish \xB7 Esc leave move mode"
+    ];
+  }
+  return width < 30 ? [
+    "\u2191\u2193 navigate",
+    "Enter/Space toggle",
+    "M move \xB7 B line break",
+    "Alt+\u2191/\u2193 quick move",
+    "Esc close"
+  ] : [
+    "\u2191\u2193 navigate \xB7 Enter/Space show/hide \xB7 M move mode",
+    "B add/remove line break after \xB7 Alt+\u2191/\u2193 quick move \xB7 Esc close"
+  ];
+}
+function segmentsDocument(current, name, shouldShow) {
+  const { parsed, rawDocument: previousDocument } = editableSettings(current, "changing segments");
+  const segments = shouldShow ? [...current.config.segments, ...current.config.segments.includes(name) ? [] : [name]] : current.config.segments.filter((segment) => segment !== name);
+  parsed.segments = normalizeLineBreaks(segments);
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "	")}
+`,
+    previousDocument
+  };
+}
+function lineBreakAfterDocument(current, name) {
+  const { parsed, rawDocument: previousDocument } = editableSettings(
+    current,
+    "changing line breaks"
+  );
+  const segments = [...current.config.segments];
+  const segmentIndex = segments.indexOf(name);
+  if (segments[segmentIndex + 1] === LINE_BREAK_SEGMENT_NAME) {
+    segments.splice(segmentIndex + 1, 1);
+  } else {
+    segments.splice(segmentIndex + 1, 0, LINE_BREAK_SEGMENT_NAME);
+  }
+  parsed.segments = segments;
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "	")}
+`,
+    previousDocument
+  };
+}
+function reorderedSegmentsDocument(current, name, direction) {
+  const dataIndexes = current.config.segments.flatMap(
+    (segment, index) => segment === LINE_BREAK_SEGMENT_NAME ? [] : [index]
+  );
+  const currentDataIndex = dataIndexes.findIndex(
+    (index) => current.config.segments[index] === name
+  );
+  const targetDataIndex = currentDataIndex + direction;
+  if (currentDataIndex < 0 || targetDataIndex < 0 || targetDataIndex >= dataIndexes.length) {
+    return void 0;
+  }
+  const { parsed, rawDocument: previousDocument } = editableSettings(
+    current,
+    "reordering segments"
+  );
+  const segments = [...current.config.segments];
+  const currentIndex = dataIndexes[currentDataIndex];
+  const targetIndex = dataIndexes[targetDataIndex];
+  if (currentIndex === void 0 || targetIndex === void 0) return void 0;
+  [segments[currentIndex], segments[targetIndex]] = [segments[targetIndex], segments[currentIndex]];
+  parsed.segments = segments;
+  return {
+    nextDocument: `${JSON.stringify(parsed, null, "	")}
+`,
+    previousDocument
+  };
+}
+function applySegmentsDocumentChange(change, ctx, options) {
+  const previous = options.getLoaded();
+  const save = options.save ?? saveStatuslineSettingsDocument;
+  const next = save(options.settingsPath, change.nextDocument);
+  try {
+    options.apply(next, ctx);
+  } catch (applyError) {
+    const rollbackError = restoreStatuslineSettings(ctx, options, previous, next);
+    if (rollbackError) {
+      throw new Error(
+        `runtime update failed: ${formatError(applyError)}; rollback failed: ${formatError(rollbackError)}`
+      );
+    }
+    throw applyError;
+  }
+  return next;
+}
+function restoreStatuslineSettings(ctx, options, previous, saved) {
+  try {
+    if (saved.rawDocument === void 0 || saved.fileIdentity === void 0) {
+      throw new Error("The saved settings document identity is unavailable");
+    }
+    removeStatuslineSettingsDocumentIfMatches(
+      options.settingsPath,
+      saved.rawDocument,
+      saved.fileIdentity
+    );
+    if (previous.rawDocument === void 0 || previous.settingsPath !== options.settingsPath) {
+      options.apply(previous, ctx);
+      return void 0;
+    }
+    const restored = (options.save ?? saveStatuslineSettingsDocument)(
+      options.settingsPath,
+      previous.rawDocument
+    );
+    options.apply(restored, ctx);
+    return void 0;
+  } catch (error) {
+    return error;
+  }
+}
+function normalizeLineBreaks(segments) {
+  const normalized = [];
+  for (const segment of segments) {
+    if (segment === LINE_BREAK_SEGMENT_NAME && (normalized.length === 0 || normalized.at(-1) === LINE_BREAK_SEGMENT_NAME)) {
+      continue;
+    }
+    normalized.push(segment);
+  }
+  if (normalized.at(-1) === LINE_BREAK_SEGMENT_NAME) normalized.pop();
+  return normalized;
+}
+function editableSettings(current, action) {
+  const rawDocument = current.source === "user" && current.rawDocument !== void 0 ? current.rawDocument : current.source === "built-in" && current.rawDocument === void 0 && current.diagnostics.length === 0 ? DEFAULT_STATUSLINE_DOCUMENT : void 0;
+  if (rawDocument === void 0 || current.diagnostics.some((item) => item.code !== "unknown")) {
+    throw new Error(`Fix pi-statusline.json before ${action}`);
+  }
+  const parsed = JSON.parse(rawDocument);
+  if (!isRecord(parsed)) throw new Error("Settings must contain a JSON object");
+  return { parsed, rawDocument };
+}
+function showStatus(ctx, options) {
+  if (!canNotify(ctx)) return;
+  const loaded = options.getLoaded();
+  const diagnostics = loaded.diagnostics.slice(0, 5).map((item) => `${item.path || "root"}: ${item.message}`).join("; ");
+  ctx.ui.notify(
+    [
+      `pi-statusline source: ${loaded.source}`,
+      `active path: ${loaded.settingsPath}`,
+      `save target: ${options.settingsPath}`,
+      `palette preset: ${loaded.config.palettePreset}`,
+      `density: ${loaded.config.density}`,
+      `separator: ${loaded.config.separator}`,
+      `information: ${inferInformationProfile(loaded.config.segments)}`,
+      `segments: ${loaded.config.segments.join(", ") || "none"}`,
+      diagnostics ? `warnings: ${diagnostics}` : "warnings: none"
+    ].join("\n"),
+    loaded.diagnostics.length > 0 ? "warning" : "info"
+  );
+}
+function showHelp(ctx, settingsPath) {
+  if (!canNotify(ctx)) return;
+  ctx.ui.notify(
+    [
+      "/statusline \u2014 open Appearance, Information, Advanced, Status, and Help",
+      "/statusline settings \u2014 edit and apply JSON",
+      "/statusline status \u2014 show source, path, information level, and warnings",
+      "/statusline help \u2014 show this help",
+      "Menu actions: Appearance, Information, Advanced, Status, Help.",
+      "Information levels: minimal, balanced, detailed; any other segment array is custom.",
+      "Advanced actions: Custom layout, Edit settings JSON, Back.",
+      `Settings: ${settingsPath}`,
+      "Fields: palettePreset, palette, density, separator, segments, segmentText, extensionStatusIcons",
+      "Named presets ignore but preserve palette; custom uses its per-segment fg/bg colors.",
+      "Responsive rows retain context, model, location, and active work before decorative data.",
+      "Custom layout can show, hide, reorder, or split data segments across rows.",
+      "Press M for move mode, Alt+Up/Alt+Down for quick move, and B for a line break.",
+      "Line breaks (line_break) may repeat when separated by data segments, but cannot be consecutive.",
+      "segmentText supports prefix and suffix strings around Pi-owned dynamic values.",
+      "segmentText.model also supports truncationLength, truncationSymbol, and truncationDirection (start, middle, end)."
+    ].join("\n"),
+    "info"
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPaletteName(value) {
+  return PALETTE_NAMES.includes(value);
+}
+function canNotify(ctx) {
+  return ctx.mode === "tui" || ctx.hasUI;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  handleStatuslineCommand,
+  registerStatuslineCommand
+};
+//# sourceMappingURL=commands-FUT5RTFK.ts.map