@narumitw/pi-files 0.0.0-stage → 0.1.0

package/src/external-editor.ts

@@ -0,0 +1,143 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { lstat, realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { getAgentDir, SettingsManager, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+
+export interface ExternalEditorProcess {
+  readonly killed: boolean;
+  kill(): boolean;
+  once(event: "close", listener: (code: number | null) => void): this;
+  once(event: "error", listener: (error: Error) => void): this;
+}
+
+export type SpawnExternalEditorProcess = (command: string, args: readonly string[]) => ExternalEditorProcess;
+
+export interface EditProjectFileInExternalEditorOptions {
+  root: string;
+  projectPath: string;
+  tui: TUI;
+  projectTrusted: boolean;
+  signal?: AbortSignal;
+  isCurrent?: () => boolean;
+  agentDir?: string;
+  command?: string;
+  spawnProcess?: SpawnExternalEditorProcess;
+}
+
+export async function editProjectFileInExternalEditor(options: EditProjectFileInExternalEditorOptions): Promise<void> {
+  options.signal?.throwIfAborted();
+  const target = await resolveEditableProjectFile(options.root, options.projectPath, options.signal);
+  options.signal?.throwIfAborted();
+  const command =
+    options.command ??
+    SettingsManager.create(options.root, options.agentDir ?? getAgentDir(), {
+      projectTrusted: options.projectTrusted,
+    }).getExternalEditorCommand();
+  const [editor, ...editorArgs] = command.trim().split(/\s+/u);
+  if (!editor) throw new Error("External editor command is empty");
+  assertEditorTargetSafeForPlatform(target);
+
+  await withFileMutationQueue(target, async () => {
+    options.signal?.throwIfAborted();
+    let stopped = false;
+    try {
+      options.tui.stop();
+      stopped = true;
+      process.stdout.write("Launching external editor. Pi will resume when the editor exits.\n");
+      await runExternalEditorProcess(editor, [...editorArgs, target], options.signal, options.spawnProcess);
+      options.signal?.throwIfAborted();
+    } finally {
+      if (stopped && !options.signal?.aborted && (options.isCurrent === undefined || options.isCurrent())) {
+        options.tui.start();
+        options.tui.requestRender(true);
+      }
+    }
+  });
+}
+
+export async function resolveEditableProjectFile(
+  root: string,
+  projectPath: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  signal?.throwIfAborted();
+  if (!projectPath || isAbsolute(projectPath) || projectPath.includes("\0")) {
+    throw new Error("File path is outside the project");
+  }
+  const canonicalRoot = await realpath(root);
+  signal?.throwIfAborted();
+  const candidate = resolve(canonicalRoot, projectPath);
+  if (!isInside(canonicalRoot, candidate)) throw new Error("File path is outside the project");
+  const candidateInfo = await lstat(candidate);
+  signal?.throwIfAborted();
+  if (candidateInfo.isSymbolicLink()) throw new Error(`${projectPath} is a symbolic link`);
+  const canonicalFile = await realpath(candidate);
+  signal?.throwIfAborted();
+  if (!isInside(canonicalRoot, canonicalFile)) throw new Error("File path is outside the project");
+  const info = await lstat(canonicalFile);
+  signal?.throwIfAborted();
+  if (!info.isFile()) throw new Error(`${projectPath} is not a regular file`);
+  return canonicalFile;
+}
+
+async function runExternalEditorProcess(
+  command: string,
+  args: readonly string[],
+  signal: AbortSignal | undefined,
+  spawnProcess: SpawnExternalEditorProcess = defaultSpawnExternalEditorProcess,
+): Promise<void> {
+  signal?.throwIfAborted();
+  const child = spawnProcess(command, args);
+  await new Promise<void>((resolvePromise, reject) => {
+    let settled = false;
+    let aborted = signal?.aborted ?? false;
+    const finish = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", abort);
+      if (error) reject(error);
+      else resolvePromise();
+    };
+    const abort = () => {
+      aborted = true;
+      if (!child.killed) child.kill();
+    };
+    child.once("error", (error) => finish(aborted ? abortError() : error));
+    child.once("close", (code) => {
+      if (aborted) {
+        finish(abortError());
+        return;
+      }
+      if (code === 0) {
+        finish();
+        return;
+      }
+      finish(new Error(`External editor exited with code ${code ?? "unknown"}`));
+    });
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+  });
+}
+
+export function assertEditorTargetSafeForPlatform(target: string, platform: NodeJS.Platform = process.platform): void {
+  if (platform === "win32" && /[\r\n"&|<>^()%!]/u.test(target)) {
+    throw new Error("File path contains characters unsafe for the Windows external-editor shell");
+  }
+}
+
+function defaultSpawnExternalEditorProcess(command: string, args: readonly string[]): ChildProcess {
+  return spawn(command, [...args], {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+  });
+}
+
+function isInside(root: string, candidate: string): boolean {
+  const result = relative(root, candidate);
+  return result === "" || (!result.startsWith(`..${sep}`) && result !== ".." && !isAbsolute(result));
+}
+
+function abortError(): DOMException {
+  return new DOMException("External editor cancelled", "AbortError");
+}

package/src/file-browser-ui.ts

@@ -0,0 +1,128 @@
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { ProjectBrowserItem } from "./file-browser.js";
+import { safeTerminalText } from "./file-browser.js";
+
+interface FileBrowserRenderOptions {
+  theme: Theme;
+  keybindings: KeybindingsManager;
+  width: number;
+  height: number;
+  items: readonly ProjectBrowserItem[];
+  selectedIndex: number;
+  scrollOffset: number;
+  currentDirectory: string;
+  searchLine: string;
+  searchActive: boolean;
+  repositoryLabel: string;
+  statuses?: ReadonlyMap<string, { code: string }>;
+  loading: boolean;
+  error?: string;
+}
+
+export function renderFileBrowser(options: FileBrowserRenderOptions): string[] {
+  const location = options.currentDirectory ? `/${options.currentDirectory}` : "/";
+  const title = options.theme.fg(
+    "accent",
+    options.theme.bold(`File Context · files · ${location}${options.repositoryLabel}`),
+  );
+  const visibleItems = options.items.slice(options.scrollOffset, options.scrollOffset + options.height);
+  const itemLines = visibleItems.map((item, visibleIndex) => {
+    const index = options.scrollOffset + visibleIndex;
+    const prefix = index === options.selectedIndex ? "> " : "  ";
+    const status = item.kind === "file" ? (options.statuses?.get(item.path)?.code ?? "  ") : "  ";
+    const suffix = item.kind === "directory" ? "/" : "";
+    const line = `${prefix}${status} ${item.label}${suffix}`;
+    return truncateToWidth(
+      index === options.selectedIndex ? options.theme.bg("selectedBg", options.theme.fg("text", line)) : line,
+      options.width,
+      "",
+    );
+  });
+  if (itemLines.length === 0) {
+    itemLines.push(truncateToWidth(options.theme.fg("muted", "  No matching files"), options.width, ""));
+  }
+  const state = options.loading
+    ? options.theme.fg("warning", "Loading…")
+    : options.error
+      ? options.theme.fg("error", safeTerminalText(options.error))
+      : options.theme.fg("muted", formatFileBrowserHint(options));
+  return [
+    truncateToWidth(title, options.width, ""),
+    truncateToWidth(options.searchLine, options.width, ""),
+    ...itemLines,
+    truncateToWidth(state, options.width, ""),
+  ];
+}
+
+function formatFileBrowserHint(options: FileBrowserRenderOptions): string {
+  const selected = options.items[options.selectedIndex];
+  const countLabel = options.searchActive
+    ? `${options.items.length} matching ${options.items.length === 1 ? "file" : "files"}`
+    : `${options.items.length} ${options.items.length === 1 ? "item" : "items"}`;
+  const navigation = navigationHint(options.keybindings);
+  const confirm = bindingHint(options.keybindings, "tui.select.confirm", ["enter"]);
+  const tab = bindingHint(options.keybindings, "tui.input.tab", ["tab"]);
+  const cancel = uniqueKeys([
+    ...bindingKeys(options.keybindings, "tui.select.cancel", ["escape"]),
+    formatHintKey("ctrl+c"),
+  ]).join("/");
+  return [
+    countLabel,
+    `${navigation} navigate`,
+    `${confirm} ${selected?.kind === "directory" ? "open folder" : "preview"}`,
+    ...(selected?.kind === "file" ? [`${tab} reference`] : []),
+    "Ctrl+F contents",
+    `${cancel} ${options.currentDirectory && !options.searchActive ? "back" : "cancel"}`,
+  ].join(" · ");
+}
+
+function navigationHint(keybindings: KeybindingsManager): string {
+  const up = bindingKeys(keybindings, "tui.select.up", ["up"]);
+  const down = bindingKeys(keybindings, "tui.select.down", ["down"]);
+  if (up.includes("↑") && down.includes("↓")) {
+    return uniqueKeys(["↑↓", ...up.filter((key) => key !== "↑"), ...down.filter((key) => key !== "↓")]).join("/");
+  }
+  return uniqueKeys([...up, ...down]).join("/");
+}
+
+export function bindingHint(
+  keybindings: KeybindingsManager,
+  binding: Parameters<KeybindingsManager["getKeys"]>[0],
+  fallback: readonly string[],
+): string {
+  return bindingKeys(keybindings, binding, fallback).join("/");
+}
+
+function bindingKeys(
+  keybindings: KeybindingsManager,
+  binding: Parameters<KeybindingsManager["getKeys"]>[0],
+  fallback: readonly string[],
+): string[] {
+  const getKeys = keybindings.getKeys?.bind(keybindings);
+  const keys = getKeys?.(binding) ?? fallback;
+  return uniqueKeys(keys.map(formatHintKey));
+}
+
+function uniqueKeys(keys: readonly string[]): string[] {
+  return [...new Set(keys.filter(Boolean))];
+}
+
+function formatHintKey(key: string): string {
+  const normalized = safeTerminalText(key).toLowerCase();
+  if (normalized === "up") return "↑";
+  if (normalized === "down") return "↓";
+  if (normalized === "left") return "←";
+  if (normalized === "right") return "→";
+  if (normalized === "return" || normalized === "enter") return "Enter";
+  if (normalized === "escape" || normalized === "esc") return "Esc";
+  if (normalized === "tab") return "Tab";
+  return normalized
+    .split("+")
+    .map((part, index) =>
+      part === "ctrl" || part === "alt" || part === "shift" || (index > 0 && part.length === 1)
+        ? `${part[0]?.toUpperCase()}${part.slice(1)}`
+        : part,
+    )
+    .join("+");
+}

package/src/file-browser.ts

@@ -0,0 +1,76 @@
+interface IndexedProjectFile {
+  path: string;
+  displayPath: string;
+  segments: readonly string[];
+}
+
+export type ProjectBrowserItem =
+  | { kind: "directory"; path: string; label: string }
+  | { kind: "file"; path: string; label: string };
+
+export class ProjectFileBrowser {
+  private readonly files: readonly IndexedProjectFile[];
+  private readonly filesByPath: ReadonlyMap<string, IndexedProjectFile>;
+
+  constructor(paths: readonly string[]) {
+    this.files = paths.map((path) => {
+      const displayPath = safeTerminalText(path);
+      return { path, displayPath, segments: displayPath.split("/") };
+    });
+    this.filesByPath = new Map(this.files.map((file) => [file.path, file]));
+  }
+
+  list(directory: string): ProjectBrowserItem[] {
+    const directorySegments = directory ? directory.split("/") : [];
+    const directories = new Map<string, ProjectBrowserItem>();
+    const files: ProjectBrowserItem[] = [];
+
+    for (const file of this.files) {
+      if (!startsWithSegments(file.segments, directorySegments)) continue;
+      const childIndex = directorySegments.length;
+      const label = file.segments[childIndex];
+      if (!label) continue;
+      if (file.segments.length > childIndex + 1) {
+        const path = [...directorySegments, label].join("/");
+        directories.set(path, { kind: "directory", path, label });
+        continue;
+      }
+      files.push({ kind: "file", path: file.path, label });
+    }
+
+    return [...[...directories.values()].sort(compareBrowserItems), ...files.sort(compareBrowserItems)];
+  }
+
+  searchResults(paths: readonly string[]): ProjectBrowserItem[] {
+    return paths.flatMap((path) => {
+      const file = this.filesByPath.get(path);
+      return file ? [{ kind: "file" as const, path: file.path, label: file.displayPath }] : [];
+    });
+  }
+}
+
+export function parentProjectDirectory(directory: string): string {
+  const separator = directory.lastIndexOf("/");
+  return separator < 0 ? "" : directory.slice(0, separator);
+}
+
+export function safeTerminalText(text: string): string {
+  return [...text]
+    .map((character) => {
+      if (character === "\t") return "    ";
+      const code = character.charCodeAt(0);
+      if (code <= 31 || (code >= 127 && code <= 159)) {
+        return `\\x${code.toString(16).padStart(2, "0")}`;
+      }
+      return character;
+    })
+    .join("");
+}
+
+function startsWithSegments(path: readonly string[], prefix: readonly string[]): boolean {
+  return prefix.every((segment, index) => path[index] === segment);
+}
+
+function compareBrowserItems(left: ProjectBrowserItem, right: ProjectBrowserItem): number {
+  return left.label < right.label ? -1 : left.label > right.label ? 1 : 0;
+}