@narumitw/pi-files 0.0.0-stage → 0.1.0

package/dist/chunks/menu-P6IBMROH.ts

@@ -0,0 +1,876 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  MAX_TARGETS,
+  createSnapshot
+} from "./chunk-NFNGJETD.ts";
+import {
+  ScopeInput,
+  exactRows,
+  scopeFrame,
+  scopeOverlayContext,
+  showScopePathInput
+} from "./chunk-3GQ7VS22.ts";
+import {
+  assertScopeTarget,
+  resolveScopeTarget
+} from "./chunk-F5QFC255.ts";
+import {
+  displayError,
+  displayFilePath,
+  displayPath
+} from "./chunk-AXW73HDJ.ts";
+
+// src/scope/menu.ts
+import { isAbsolute as isAbsolute2, relative as relative2, sep as sep2 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { defineMenu, runMenu, runTask } from "@narumitw/pi-tui-kit";
+
+// src/scope/files.ts
+import fs from "node:fs/promises";
+import { resolve } from "node:path";
+var MAX_SCOPE_FILES = 5e3;
+var MAX_SCOPE_ENTRIES = 2e4;
+var MAX_SCOPE_DEPTH = 64;
+var SCOPE_EXCLUDED_DIRECTORIES = Object.freeze([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "build",
+  "coverage",
+  "dist",
+  "target",
+  ".next"
+]);
+var excludedDirectories = new Set(SCOPE_EXCLUDED_DIRECTORIES);
+function scanError(action, path, cause) {
+  const code = cause && typeof cause === "object" && "code" in cause ? ` (${String(cause.code)})` : "";
+  return new Error(`Scope cannot ${action} ${JSON.stringify(path)}${code}. Check access and retry.`, { cause });
+}
+async function closeDirectory(handle, path, signal) {
+  try {
+    await handle.close();
+  } catch (error) {
+    signal?.throwIfAborted();
+    throw scanError("close directory", path, error);
+  }
+  signal?.throwIfAborted();
+}
+async function discoverScopeFiles(cwd, showHiddenFiles, signal) {
+  const files = [];
+  let entryCount = 0;
+  const directories = [{ directory: resolve(cwd), depth: 0 }];
+  for (const { directory, depth } of directories) {
+    signal?.throwIfAborted();
+    if (depth > MAX_SCOPE_DEPTH) {
+      throw new Error(`Scope scan exceeds depth ${MAX_SCOPE_DEPTH}. Open a narrower working directory.`);
+    }
+    let handle;
+    try {
+      handle = await fs.opendir(directory);
+    } catch (error) {
+      signal?.throwIfAborted();
+      throw scanError("open directory", directory, error);
+    }
+    try {
+      signal?.throwIfAborted();
+      while (true) {
+        let entry;
+        try {
+          entry = await handle.read();
+        } catch (error) {
+          signal?.throwIfAborted();
+          throw scanError("read directory", directory, error);
+        }
+        signal?.throwIfAborted();
+        if (!entry) break;
+        entryCount += 1;
+        if (entryCount > MAX_SCOPE_ENTRIES) {
+          throw new Error(`Scope scan exceeds ${MAX_SCOPE_ENTRIES} entries. Open a narrower working directory.`);
+        }
+        if (entry.isSymbolicLink() || !showHiddenFiles && entry.name.startsWith(".")) continue;
+        if (entry.isDirectory() && excludedDirectories.has(entry.name)) continue;
+        const path = resolve(directory, entry.name);
+        let stats;
+        try {
+          stats = await fs.lstat(path);
+        } catch (error) {
+          signal?.throwIfAborted();
+          throw scanError("inspect entry", path, error);
+        }
+        signal?.throwIfAborted();
+        if (stats.isSymbolicLink()) continue;
+        if (stats.isDirectory()) {
+          if (!excludedDirectories.has(entry.name)) directories.push({ directory: path, depth: depth + 1 });
+        } else if (stats.isFile()) {
+          files.push(path);
+          if (files.length > MAX_SCOPE_FILES) {
+            throw new Error(`Scope scan exceeds ${MAX_SCOPE_FILES} files. Open a narrower working directory.`);
+          }
+        }
+      }
+    } finally {
+      await closeDirectory(handle, directory, signal);
+    }
+  }
+  signal?.throwIfAborted();
+  return files.sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+}
+
+// src/scope/picker.ts
+import { isAbsolute, relative, sep } from "node:path";
+import {
+  fuzzyFilter,
+  SelectList,
+  stripTerminalSequences,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+import { runCustomInteraction } from "@narumitw/pi-tui-kit";
+
+// src/scope/picker-keys.ts
+import { getKeybindings, matchesKey, TUI_KEYBINDINGS } from "@earendil-works/pi-tui";
+import { formatInteractionHints } from "@narumitw/pi-tui-kit";
+var selection = [
+  ["cancel", "tui.select.cancel"],
+  ["up", "tui.select.up"],
+  ["down", "tui.select.down"],
+  ["pageUp", "tui.select.pageUp"],
+  ["pageDown", "tui.select.pageDown"],
+  ["apply", "tui.select.confirm"]
+];
+var editing = [
+  "tui.editor.undo",
+  "tui.input.submit",
+  "tui.editor.deleteCharBackward",
+  "tui.editor.deleteCharForward",
+  "tui.editor.deleteWordBackward",
+  "tui.editor.deleteWordForward",
+  "tui.editor.deleteToLineStart",
+  "tui.editor.deleteToLineEnd",
+  "tui.editor.yank",
+  "tui.editor.yankPop",
+  "tui.editor.cursorLeft",
+  "tui.editor.cursorRight",
+  "tui.editor.cursorLineStart",
+  "tui.editor.cursorLineEnd",
+  "tui.editor.cursorWordLeft",
+  "tui.editor.cursorWordRight"
+];
+var viewportBindings = Object.keys(TUI_KEYBINDINGS).filter(
+  (binding) => binding.startsWith("tui.altScreen.") && !binding.startsWith("tui.altScreen.search")
+);
+var hintInputs = [
+  "\r",
+  "\n",
+  "\x1BOM",
+  "\x1B",
+  "	",
+  "\x1B[Z",
+  "",
+  "",
+  "\x1Bo",
+  "\x1B[111;3u",
+  "\x1B[A",
+  "\x1B[B",
+  "\x1B[5~",
+  "\x1B[6~",
+  ...["OP", "OQ", "OR", "OS", "[15~", "[17~", "[18~", "[19~", "[20~", "[21~", "[23~", "[24~"].map(
+    (suffix) => `\x1B${suffix}`
+  ),
+  ..."abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "
+];
+function pickerKeys(tui, keybindings) {
+  const hostAllows = (data) => {
+    if (tui.onDebug && matchesKey(data, "shift+ctrl+d")) return false;
+    if (tui.mode !== "fullscreen") return true;
+    const host = getKeybindings();
+    if (host.matches(data, "tui.altScreen.search")) return false;
+    return tui.hasOverlay() || !viewportBindings.some((binding) => host.matches(data, binding));
+  };
+  const filesAction = (data) => {
+    if (matchesKey(data, "ctrl+c")) return "close";
+    for (const [name, binding] of selection) if (keybindings.matches(data, binding)) return name;
+    if (data === "\n" || editing.some((binding) => keybindings.matches(data, binding))) return "input";
+    if (keybindings.matches(data, "tui.input.tab")) return "mark";
+    if (matchesKey(data, "shift+tab")) return "markUp";
+    if (keybindings.matches(data, "app.session.togglePath")) return "paths";
+  };
+  const addKey = () => ["ctrl+o", "alt+o"].find((key) => {
+    const inputs = hintInputs.filter((input) => matchesKey(input, key));
+    return inputs.length > 0 && inputs.every((input) => hostAllows(input) && filesAction(input) === void 0);
+  });
+  const action = (data, panel) => {
+    if (panel === "files") {
+      const native = filesAction(data);
+      if (native) return native;
+      const add = addKey();
+      if (add && matchesKey(data, add)) return "add";
+      return;
+    }
+    if (matchesKey(data, "ctrl+c")) return "close";
+    if (keybindings.matches(data, "tui.select.cancel")) return "cancel";
+    if (keybindings.matches(data, "tui.editor.undo")) return "input";
+    if (keybindings.matches(data, "tui.input.submit") || data === "\n") return "submit";
+    return "input";
+  };
+  const bindings = (panel) => ({
+    getKeys(name) {
+      const binding = name === "mark" ? "tui.input.tab" : name === "paths" ? "app.session.togglePath" : name === "submit" ? "tui.input.submit" : selection.find(([action2]) => action2 === name)?.[1];
+      const candidates = name === "markUp" ? ["shift+tab"] : name === "add" ? [addKey()].filter((key2) => key2 !== void 0) : binding ? keybindings.getKeys(binding) : [];
+      const key = candidates.find((key2) => {
+        const inputs = hintInputs.filter((input) => matchesKey(input, key2));
+        return inputs.length > 0 && inputs.every((input) => hostAllows(input) && action(input, panel) === name);
+      });
+      return key ? [key] : [];
+    }
+  });
+  const label = (name, text, panel = "files") => formatInteractionHints(bindings(panel), [{ bindings: [name], label: text }]) || text;
+  const hints = (panel, count, busy) => {
+    const keys = bindings(panel);
+    const controls = formatInteractionHints(keys, [
+      ...!busy ? panel === "files" ? [
+        { bindings: ["mark"], label: "select" },
+        { bindings: ["apply"], label: count ? "apply" : "apply (select files)" },
+        { bindings: ["markUp"], label: "select \u2191" }
+      ] : [{ bindings: ["submit"], label: "add file" }] : [],
+      { bindings: ["cancel"], excludeKeys: ["ctrl+c"], label: panel === "files" ? "cancel" : "back" },
+      ...!keys.getKeys("cancel").length && hostAllows("") ? [{ keys: ["ctrl+c"], label: "close" }] : []
+    ]);
+    return panel === "files" ? `${count} selected \u2022 ${controls}` : controls;
+  };
+  return { action, hints, label };
+}
+
+// src/scope/picker.ts
+var LIST_ROWS = 10;
+function outsideCwd(cwd, path) {
+  const fromCwd = relative(cwd, path);
+  return isAbsolute(fromCwd) || fromCwd === ".." || fromCwd.startsWith(`..${sep}`);
+}
+function showScopePicker(ctx, options) {
+  return runCustomInteraction(ctx, {
+    signal: options.signal,
+    isCurrent: options.isCurrent,
+    create: ({ tui, theme, keybindings, signal: ownerSignal, complete }) => {
+      const controller = new AbortController();
+      const signal = AbortSignal.any([ownerSignal, controller.signal]);
+      const placeholder = (text) => theme.fg("dim", text);
+      const search = new ScopeInput("Search files\u2026", placeholder);
+      const pathInput = new ScopeInput("Existing file path\u2026", placeholder);
+      const keys = pickerKeys(tui, keybindings);
+      const checked = new Set(options.targets.map((target) => target.path));
+      const added = /* @__PURE__ */ new Map();
+      let panel = "files";
+      let focused = false;
+      let fullPaths = false;
+      let paths = [];
+      let rows = [];
+      let list;
+      let loading = true;
+      let validating;
+      let operation;
+      let pending = Promise.resolve();
+      let disposed = false;
+      let closing = false;
+      let error = "";
+      let notice = "";
+      let pressed;
+      let mouseLayout;
+      const cancelPress = () => {
+        if (pressed) pressed = { kind: "cancelled" };
+      };
+      const relativePath = (path) => outsideCwd(options.cwd, path) ? path : relative(options.cwd, path) || ".";
+      const pathLabel = (path) => displayFilePath(fullPaths ? path : relativePath(path));
+      const syncFocus = () => {
+        search.input.focused = focused && panel === "files";
+        pathInput.input.focused = focused && panel === "path";
+      };
+      const current = () => {
+        if (disposed || closing || signal.aborted) return false;
+        if (options.isCurrent()) return true;
+        closing = true;
+        complete({ kind: "cancelled", reason: "close" });
+        controller.abort();
+        return false;
+      };
+      const close = (value) => {
+        if (!current()) return;
+        closing = true;
+        complete(value);
+        controller.abort();
+      };
+      const rebuild = (selectedId = list?.getSelectedItem()?.value) => {
+        cancelPress();
+        const query = displayPath(search.input.getValue()).slice(1, -1);
+        rows = fuzzyFilter(paths, query, (path) => displayPath(relativePath(path)).slice(1, -1)).map((path) => ({
+          value: path,
+          label: `${checked.has(path) ? "[x]" : "[ ]"} ${outsideCwd(options.cwd, path) ? "(outside) " : ""}${pathLabel(path)}`
+        }));
+        list = new SelectList(rows, LIST_ROWS, {
+          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(
+          Math.max(
+            0,
+            rows.findIndex((row) => row.value === selectedId)
+          )
+        );
+      };
+      const runValidation = (kind, work) => {
+        const owned = new AbortController();
+        const operationSignal = AbortSignal.any([signal, owned.signal]);
+        operation = owned;
+        validating = kind;
+        error = "";
+        pending = (async () => {
+          try {
+            await work(operationSignal);
+          } catch (failure) {
+            if (current() && !operationSignal.aborted) error = displayError(failure);
+          } finally {
+            if (operation === owned) {
+              operation = void 0;
+              validating = void 0;
+            }
+            if (current()) tui.requestRender();
+          }
+        })();
+      };
+      const apply = () => {
+        if (!current() || loading || validating) return;
+        const selectedPaths = paths.filter((path) => checked.has(path));
+        if (!selectedPaths.length) {
+          error = "Select at least one file first.";
+          return;
+        }
+        runValidation("selection", async (operationSignal) => {
+          const targets = await options.validate(selectedPaths, operationSignal, [...added.values()]);
+          if (current() && !operationSignal.aborted) close({ kind: "selected", targets });
+        });
+      };
+      const addPath = () => {
+        if (!current() || loading || validating) return;
+        const raw = pathInput.input.getValue();
+        if (!raw.length) {
+          error = "Enter an existing file path.";
+          return;
+        }
+        runValidation("path", async (operationSignal) => {
+          const target = await options.resolvePath(raw, operationSignal);
+          if (!current() || operationSignal.aborted) return;
+          if (!added.has(target.path) && added.size >= MAX_TARGETS) {
+            throw new Error(`Add no more than ${MAX_TARGETS} distinct paths in one picker.`);
+          }
+          const previous = list.getSelectedItem()?.value;
+          added.set(target.path, { path: target.path, canonical: target.canonical });
+          if (!paths.includes(target.path)) paths.push(target.path);
+          checked.add(target.path);
+          pathInput.input.setValue("");
+          panel = "files";
+          syncFocus();
+          rebuild(target.path);
+          if (!rows.some((row) => row.value === target.path))
+            list.setSelectedIndex(
+              Math.max(
+                0,
+                rows.findIndex((row) => row.value === previous)
+              )
+            );
+          notice = `Added ${pathLabel(target.path)}`;
+        });
+      };
+      const mark = (id, move = 0) => {
+        if (!current() || loading || validating) return;
+        const index = rows.findIndex((row) => row.value === id);
+        if (index < 0) return;
+        if (checked.has(id)) checked.delete(id);
+        else checked.add(id);
+        error = "";
+        notice = "";
+        const next = rows[Math.max(0, Math.min(rows.length - 1, index + move))]?.value;
+        rebuild(next);
+      };
+      const perform = (command) => {
+        if (command === "close") close({ kind: "cancelled", reason: "close" });
+        else if (command === "cancel") {
+          if (panel === "files") close({ kind: "cancelled", reason: "back" });
+          else {
+            operation?.abort();
+            panel = "files";
+            error = "";
+            syncFocus();
+          }
+        } else if (loading || validating) return;
+        else if (command === "apply") apply();
+        else if (command === "submit") addPath();
+        else if (command === "add") {
+          panel = "path";
+          error = "";
+          notice = "";
+          cancelPress();
+          syncFocus();
+        } else if (command === "paths") {
+          fullPaths = !fullPaths;
+          rebuild();
+        } else if (command === "mark" || command === "markUp") {
+          const id = list.getSelectedItem()?.value;
+          if (id) mark(id, command === "mark" ? 1 : -1);
+        } else if (command === "up" || command === "down" || command === "pageUp" || command === "pageDown") {
+          const index = rows.findIndex((row) => row.value === list.getSelectedItem()?.value);
+          if (index < 0) return;
+          if (command === "pageUp" || command === "pageDown")
+            list.setSelectedIndex(index + (command === "pageUp" ? -LIST_ROWS : LIST_ROWS));
+          else list.setSelectedIndex((index + (command === "up" ? -1 : 1) + rows.length) % rows.length);
+        }
+      };
+      const handleInput = (data) => {
+        if (!current()) return;
+        cancelPress();
+        const activeInput = search.isPasting ? search : pathInput.isPasting ? pathInput : panel === "files" ? search : pathInput;
+        const previous = activeInput.input.getValue();
+        let remaining;
+        activeInput.handleInput(
+          data,
+          (data2) => {
+            const command = keys.action(data2, panel);
+            if (command === "cancel" || command === "close") {
+              perform(command);
+              return true;
+            }
+            if (validating) return true;
+            if (!command || command === "input") return false;
+            perform(command);
+            return true;
+          },
+          !validating,
+          (tail) => {
+            remaining = tail;
+          }
+        );
+        if (!current()) return;
+        if (activeInput.input.getValue() !== previous) {
+          error = "";
+          notice = "";
+          if (activeInput === search && !loading) rebuild("");
+        }
+        if (remaining) handleInput(remaining);
+        if (current()) tui.requestRender();
+      };
+      rebuild();
+      pending = (async () => {
+        try {
+          const discovered = await options.discover(signal);
+          if (!current()) return;
+          paths = [.../* @__PURE__ */ new Set([...options.targets.map((target) => target.path), ...discovered])];
+          loading = false;
+          rebuild();
+          tui.requestRender();
+        } catch (failure) {
+          if (current()) close({ kind: "error", error: failure });
+        }
+      })();
+      return {
+        get focused() {
+          return focused;
+        },
+        set focused(value) {
+          focused = value;
+          syncFocus();
+        },
+        render(width) {
+          const safeWidth = Math.max(1, width);
+          const activeInput = panel === "files" ? search : pathInput;
+          const pasting = search.isPasting || pathInput.isPasting;
+          const busy = loading || validating !== void 0 || pasting;
+          const selectedIndex = rows.findIndex((row) => row.value === list.getSelectedItem()?.value);
+          const start = Math.max(0, Math.min(selectedIndex - Math.floor(LIST_ROWS / 2), rows.length - LIST_ROWS));
+          const activeRow = rows[selectedIndex];
+          const content = [...activeInput.render(safeWidth)];
+          const filesStart = content.length + 1;
+          let focusedRow = 0;
+          if (panel === "files") {
+            const listRows = loading ? [theme.fg("dim", "Scanning files\u2026")] : rows.length ? list.render(safeWidth) : [theme.fg("dim", "No matching files")];
+            content.push("", ...listRows);
+            focusedRow = rows.length && !loading ? filesStart + selectedIndex - start : 0;
+            const target = added.get(activeRow?.value ?? "") ?? options.targets.find((target2) => target2.path === activeRow?.value);
+            const preview = [
+              ...activeRow && !stripTerminalSequences(listRows[selectedIndex - start] ?? "").includes(activeRow.label) ? [`Path: ${pathLabel(activeRow.value)}`] : [],
+              ...target && (outsideCwd(options.cwd, target.path) || outsideCwd(options.cwd, target.canonical)) ? ["Outside the current directory."] : [],
+              ...target && target.path !== target.canonical ? [`Canonical target: ${pathLabel(target.canonical)}`] : []
+            ];
+            content.push(
+              ...preview.flatMap((line) => exactRows(line, safeWidth).map((part) => theme.fg("muted", part)))
+            );
+          } else if (pathInput.input.getValue()) {
+            content.push(
+              ...exactRows(`Path: ${displayPath(pathInput.input.getValue())}`, safeWidth).map(
+                (line) => theme.fg("muted", line)
+              )
+            );
+          }
+          if (notice) content.push(...exactRows(notice, safeWidth).map((line) => theme.fg("muted", line)));
+          if (error) content.push(...exactRows(error, safeWidth).map((line) => theme.fg("error", line)));
+          if (validating)
+            content.push(
+              theme.fg(
+                "dim",
+                operation?.signal.aborted ? "Finishing file check\u2026" : validating === "path" ? "Checking file\u2026" : "Checking selected files\u2026"
+              )
+            );
+          const pathModeLabel = fullPaths ? "Relative paths" : "Full paths";
+          const buttons = panel === "files" ? [
+            { action: "apply", label: options.completionLabel, enabled: !busy && checked.size > 0 },
+            { action: "add", label: pasting ? "Add file\u2026" : keys.label("add", "Add file\u2026"), enabled: !busy },
+            {
+              action: "paths",
+              label: pasting ? pathModeLabel : keys.label("paths", pathModeLabel),
+              enabled: !busy
+            }
+          ] : [
+            { action: "cancel", label: "Back", enabled: !pasting },
+            { action: "submit", label: "Add file", enabled: !busy && pathInput.input.getValue().length > 0 }
+          ];
+          let column = 0;
+          const spans = buttons.map((button) => {
+            const text = `[ ${button.label} ]`;
+            const span = {
+              start: column,
+              end: column + visibleWidth(text),
+              action: button.action,
+              enabled: button.enabled
+            };
+            column = span.end + 2;
+            return { ...span, text: theme.fg(button.enabled ? "muted" : "dim", text) };
+          });
+          const buttonRow = content.length;
+          content.push(spans.map((span) => span.text).join("  "));
+          const frame = scopeFrame(
+            tui,
+            theme,
+            width,
+            panel === "files" ? "Select files" : "Add existing file",
+            [`Cwd: ${displayFilePath(options.cwd)}`],
+            content,
+            [focusedRow, 0, buttonRow],
+            focusedRow,
+            [pasting ? `${checked.size} selected \u2022 Pasting\u2026` : keys.hints(panel, checked.size, busy)]
+          );
+          const buttonFrameRow = frame.contentRows.find((row) => row.contentIndex === buttonRow)?.frameIndex;
+          mouseLayout = {
+            width,
+            input: frame.contentRows.find((row) => row.contentIndex === 0)?.frameIndex,
+            rows: new Map(
+              panel === "files" ? frame.contentRows.flatMap((row) => {
+                const native = row.contentIndex - filesStart;
+                const id = rows[start + native]?.value;
+                return native >= 0 && native < Math.min(LIST_ROWS, rows.length) && id ? [[row.frameIndex, id]] : [];
+              }) : []
+            ),
+            buttons: buttonFrameRow === void 0 ? [] : spans.filter((span) => span.enabled && span.end <= width).map((span) => ({ row: buttonFrameRow, start: span.start, end: span.end, action: span.action }))
+          };
+          return frame.lines;
+        },
+        handleInput,
+        handleMouse(event) {
+          if (!current() || !mouseLayout || event.width !== mouseLayout.width || search.isPasting || pathInput.isPasting)
+            return;
+          if (event.type === "click" && event.button === "left" && pressed) {
+            const target = pressed;
+            pressed = void 0;
+            if (target.kind === "file") mark(target.id);
+            else if (target.kind === "button") perform(target.action);
+            return { handled: true, render: target.kind !== "cancelled" };
+          }
+          if (event.type === "press" && event.button === "left") pressed = void 0;
+          const button = mouseLayout.buttons.find(
+            (button2) => button2.row === event.y && event.x >= button2.start && event.x < button2.end
+          );
+          if (button && event.button === "left") {
+            if (event.type === "press") pressed = { kind: "button", action: button.action };
+            else if (event.type === "click") perform(button.action);
+            else return;
+            return { handled: true, render: true, focus: event.type === "press" };
+          }
+          if (loading || validating) return;
+          if (event.y === mouseLayout.input) {
+            const result = (panel === "files" ? search : pathInput).handleMouse({ ...event, y: 0, height: 1 });
+            if (event.type === "press" && result?.handled) pressed = { kind: "cancelled" };
+            return result;
+          }
+          const id = mouseLayout.rows.get(event.y);
+          if (!id) return;
+          if (event.type === "wheel" && event.wheelDelta) {
+            cancelPress();
+            const selected = rows.findIndex((row) => row.value === list.getSelectedItem()?.value);
+            list.setSelectedIndex(Math.max(0, Math.min(rows.length - 1, selected + (event.wheelDelta < 0 ? -1 : 1))));
+          } else if (event.type === "press" && event.button === "left") {
+            pressed = { kind: "file", id };
+            list.setSelectedIndex(rows.findIndex((row) => row.value === id));
+          } else if (event.type === "click" && event.button === "left") mark(id);
+          else return;
+          return { handled: true, render: true, focus: event.type === "press" };
+        },
+        invalidate() {
+          cancelPress();
+          mouseLayout = void 0;
+          search.input.invalidate();
+          pathInput.input.invalidate();
+          list.invalidate();
+        },
+        waitForPending: () => pending,
+        dispose() {
+          if (disposed) return;
+          disposed = true;
+          pressed = void 0;
+          controller.abort();
+        }
+      };
+    }
+  });
+}
+
+// src/scope/menu.ts
+function stateLines(view) {
+  return [
+    `Cwd: ${displayPath(view.cwd)}`,
+    view.state === "inactive" ? "Not restricted" : `Editing limited to ${view.targets.length} file${view.targets.length === 1 ? "" : "s"}`,
+    ...view.state === "blocked" ? ["Restriction blocked: repair the allowed files or explicitly end the restriction."] : [],
+    ...view.error ? [displayError(view.error)] : []
+  ];
+}
+async function showScopeMenu(context, options) {
+  if (context.mode !== "tui" || !context.hasUI) throw new Error("/edit-scope requires interactive TUI mode.");
+  const ctx = scopeOverlayContext(context);
+  const current = () => !options.signal.aborted && options.isCurrent();
+  const notify = (error) => {
+    if (current()) ctx.ui.notify(displayError(error), "error");
+  };
+  let pendingNew;
+  const definition = defineMenu({
+    start: "main",
+    screens: {
+      main: ({ state }) => ({
+        kind: "actions",
+        title: "Edit Scope",
+        lines: stateLines(state),
+        hint: "close",
+        items: [
+          {
+            id: "select",
+            label: state.state === "inactive" ? "Select files\u2026" : "Change allowed files\u2026",
+            action: "select"
+          },
+          { id: "new", label: state.state === "inactive" ? "New file\u2026" : "Use only a new file\u2026", action: "new" },
+          { id: "settings", label: "Settings", to: "settings" },
+          { id: "status", label: "Status", to: "status" },
+          { id: "help", label: "Help", to: "help" },
+          ...state.state === "inactive" ? [] : [{ id: "off", label: "End restriction", action: "off" }],
+          { id: "close", label: "Close", close: true }
+        ]
+      }),
+      "new-review": ({ state }) => {
+        if (!pendingNew) throw new Error("No new-file target to review.");
+        const outside = [pendingNew.path, pendingNew.canonical].some((path) => {
+          const fromCwd = relative2(state.cwd, path);
+          return isAbsolute2(fromCwd) || fromCwd === ".." || fromCwd.startsWith(`..${sep2}`);
+        });
+        return {
+          kind: "review",
+          title: "Review new file",
+          content: [
+            ...state.state === "inactive" ? [] : ["This replaces the complete allowed-file set with one file."],
+            ...outside ? ["Outside the current directory."] : [],
+            ...pendingNew.canonical !== pendingNew.path ? ["The canonical target differs from the entered path."] : [],
+            `Path: ${displayPath(pendingNew.path)}`,
+            ...pendingNew.canonical !== pendingNew.path ? [`Canonical target: ${displayPath(pendingNew.canonical)}`] : [],
+            "Reserved only. The first normal write creates the file and parent directories."
+          ].join("\n"),
+          format: { kind: "text" },
+          viewportSize: "adaptive",
+          confirm: {
+            id: "apply-new",
+            label: state.state === "inactive" ? "Start restriction" : "Replace allowed files with this new file",
+            action: "apply-new"
+          },
+          hint: "back"
+        };
+      },
+      settings: () => ({
+        kind: "settings",
+        title: "Edit Scope Settings",
+        lines: ["User setting. Changes are saved immediately."],
+        items: [
+          {
+            id: "hidden",
+            label: "Show hidden files",
+            description: "Include hidden files and directories in the picker. This does not change the active restriction.",
+            currentValue: options.getSettings().showHiddenFiles ? "true" : "false",
+            values: ["false", "true"],
+            action: "hidden"
+          }
+        ]
+      }),
+      status: ({ state }) => ({
+        kind: "review",
+        title: "Edit Scope Status",
+        lines: stateLines(state),
+        content: [
+          ...state.targets.flatMap((target, index) => [
+            `${index + 1}. ${displayPath(target.path)}`,
+            ...target.path === target.canonical ? [] : [`   Canonical: ${displayPath(target.canonical)}`]
+          ]),
+          "",
+          "Missing selected paths are reserved. The first normal write creates the file and parent directories.",
+          "While restricted, write/edit are limited to exact allowed targets. Supported readers remain available.",
+          "Shell commands, tests, formatters, and opaque writing/delegation tools are blocked; use /edit-scope off first.",
+          "This guard is not an OS sandbox. User shell commands, other programs, filesystem races, and trusted extensions are outside its boundary."
+        ].join("\n"),
+        format: { kind: "text" },
+        viewportSize: "adaptive",
+        hint: "back"
+      }),
+      help: () => ({
+        kind: "detail",
+        title: "Edit Scope Help",
+        lines: [
+          "Select files to start a restriction or replace the complete allowed-file set.",
+          "Typing searches files, including spaces and directory fragments. By default, Tab toggles and moves down, Shift+Tab toggles and moves up, and Enter applies the checked files. Marking stops at the first or last match. The footer follows your configured keys.",
+          "Project paths are relative to cwd by default. Use Full paths to switch views without changing the search or selected files.",
+          "Use Add file for an existing full, ~/ or relative path, including files outside cwd. This separate field preserves the search and checked draft; adding does not apply the restriction.",
+          "New file reserves one target; it replaces all allowed files and creates no content here.",
+          "Cancelling a draft, closing this menu, and run completion do not release the restriction.",
+          "Use End restriction or /edit-scope off to release it explicitly.",
+          "Discovery starts at cwd, skips symlinks and fixed generated/dependency/version-control directories, and does not use .gitignore.",
+          "Settings controls only hidden-file discovery. Selected targets remain visible even when discovery would exclude them.",
+          "Status lists every selected path and the tool limitations."
+        ],
+        hint: "back"
+      })
+    },
+    actions: {
+      select: async ({ signal }) => {
+        const view = options.getView();
+        const live = new Map(view.targets.map((target) => [target.path, target]));
+        const result = await showScopePicker(ctx, {
+          cwd: view.cwd,
+          targets: view.targets,
+          completionLabel: view.state === "inactive" ? "Start restriction" : "Apply changes",
+          signal,
+          isCurrent: current,
+          discover: (scanSignal) => discoverScopeFiles(view.cwd, options.getSettings().showHiddenFiles, scanSignal),
+          resolvePath: async (raw, validationSignal) => {
+            const target = await resolveScopeTarget(raw, view.cwd, "existing", validationSignal);
+            if (!current() || validationSignal.aborted)
+              throw validationSignal.reason ?? new Error("Scope flow is stale.");
+            return target;
+          },
+          validate: async (paths, validationSignal, added) => {
+            if (paths.length > MAX_TARGETS) throw new Error(`Select no more than ${MAX_TARGETS} files.`);
+            const manual = new Map(added.map((target) => [target.path, target]));
+            const known = new Map([...live, ...manual]);
+            const targets = [];
+            for (const path of paths) {
+              const nativePath = pathToFileURL(path).href;
+              const existing = known.get(path);
+              if (existing) {
+                let checked = existing;
+                if (manual.has(path)) {
+                  checked = await resolveScopeTarget(nativePath, view.cwd, "existing", validationSignal);
+                  if (!current() || validationSignal.aborted)
+                    throw validationSignal.reason ?? new Error("Scope flow is stale.");
+                  if (checked.canonical !== existing.canonical)
+                    throw new Error(`The added target changed: ${displayPath(path)}. Add it again.`);
+                }
+                await assertScopeTarget(nativePath, view.cwd, [existing], validationSignal);
+                if (!current() || validationSignal.aborted)
+                  throw validationSignal.reason ?? new Error("Scope flow is stale.");
+                targets.push(checked);
+              } else {
+                const target = await resolveScopeTarget(nativePath, view.cwd, "existing", validationSignal);
+                if (!current() || validationSignal.aborted)
+                  throw validationSignal.reason ?? new Error("Scope flow is stale.");
+                targets.push(target);
+              }
+            }
+            createSnapshot(view.cwd, targets);
+            return targets;
+          }
+        });
+        if (!current() || signal.aborted || result.kind === "stale") return { kind: "close" };
+        if (result.kind !== "completed") return { kind: "stay" };
+        if (result.value.kind === "cancelled") return { kind: result.value.reason === "close" ? "close" : "stay" };
+        if (result.value.kind === "error") {
+          notify(result.value.error);
+          return { kind: "stay" };
+        }
+        if (result.value.targets.length === 0) {
+          ctx.ui.notify("No files selected. The restriction is unchanged.", "info");
+          return { kind: "stay" };
+        }
+        const selected = result.value.targets;
+        const applied = await runTask(ctx, {
+          label: "Applying editing scope\u2026",
+          signal,
+          isCurrent: current,
+          task: ({ signal: operation }) => options.apply(selected, false, operation),
+          onError: (_ctx, error) => notify(error)
+        });
+        return { kind: applied.kind === "completed" || applied.kind === "stale" ? "close" : "stay" };
+      },
+      new: async ({ signal }) => {
+        const view = options.getView();
+        const result = await showScopePathInput(ctx, {
+          cwd: view.cwd,
+          signal,
+          isCurrent: current
+        });
+        if (!current() || signal.aborted || result.kind === "stale") return { kind: "close" };
+        if (result.kind !== "completed") return { kind: "stay" };
+        if (result.value.kind === "cancelled") return { kind: result.value.reason === "close" ? "close" : "stay" };
+        pendingNew = result.value.target;
+        return { kind: "to", screen: "new-review" };
+      },
+      "apply-new": async ({ signal }) => {
+        if (!current() || signal.aborted || !pendingNew) return { kind: "close" };
+        const target = pendingNew;
+        const applied = await runTask(ctx, {
+          label: "Applying new-file scope\u2026",
+          signal,
+          isCurrent: current,
+          task: ({ signal: operation }) => options.apply([target], true, operation),
+          onError: (_ctx, error) => notify(error)
+        });
+        return { kind: applied.kind === "completed" || applied.kind === "stale" ? "close" : "stay" };
+      },
+      hidden: async ({ value, signal }) => {
+        if (!current() || signal.aborted) return { kind: "close" };
+        await options.saveShowHiddenFiles(value === "true");
+        if (!current() || signal.aborted) return { kind: "close" };
+        return { kind: "stay" };
+      },
+      off: async ({ signal }) => {
+        if (!current() || signal.aborted) return { kind: "close" };
+        await options.off();
+        return { kind: "close" };
+      }
+    }
+  });
+  await runMenu(ctx, definition, {
+    signal: options.signal,
+    isCurrent: current,
+    getState: () => options.getView(),
+    onError: (_ctx, error) => notify(error)
+  });
+}
+export {
+  showScopeMenu
+};
+//# sourceMappingURL=menu-P6IBMROH.ts.map