@groeponline/pi-wishcraft 0.17.3

package/bash-mode/editor.ts

@@ -0,0 +1,437 @@
+import {
+  CustomEditor,
+  type KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import {
+  isKeyRelease,
+  matchesKey,
+} from "@earendil-works/pi-tui";
+import type { AutocompleteProvider } from "@earendil-works/pi-tui";
+import { matchesConfiguredShortcut } from "../src/shortcuts/matching.ts";
+import { getOneOffBashCommandContext } from "./completion.ts";
+import {
+  DEFAULT_EDITOR_BOUNDARY_SHORTCUTS,
+  droppedPathTextFromInput,
+  isCommandUndoShortcut,
+  isPrintableInput,
+  resetShellHistoryBrowse,
+} from "./editor-input.ts";
+import { overlayGhostSuggestion } from "./editor-ghost.ts";
+import type {
+  BashModeEditorOptions,
+  GhostSuggestion,
+} from "./types.ts";
+
+export class BashModeEditor extends CustomEditor {
+  private readonly keybindingsRef: KeybindingsManager;
+  private readonly optionsRef: BashModeEditorOptions;
+  private wrappedProviderInstalled = false;
+  private shellHistoryIndex = -1;
+  private shellHistoryItems: string[] = [];
+  private shellHistoryDraft = "";
+  private promptHistoryDraft: string | null = null;
+  private ghost: GhostSuggestion | null = null;
+  private ghostAbort: AbortController | null = null;
+  private ghostToken = 0;
+
+  constructor(
+    tui: any,
+    theme: any,
+    keybindings: KeybindingsManager,
+    options: BashModeEditorOptions,
+  ) {
+    super(tui, theme, keybindings);
+    this.keybindingsRef = keybindings;
+    this.optionsRef = options;
+  }
+
+  setAutocompleteProvider(provider: AutocompleteProvider): void {
+    super.setAutocompleteProvider(provider);
+    this.wrappedProviderInstalled = false;
+  }
+
+  installAutocompleteProvider(provider: AutocompleteProvider): void {
+    this.setAutocompleteProvider(provider);
+    this.wrappedProviderInstalled = true;
+  }
+
+  hasWrappedProvider(): boolean {
+    return this.wrappedProviderInstalled;
+  }
+
+  getGhostSuggestion(): GhostSuggestion | null {
+    return this.isShellCompletionContext() ? this.ghost : null;
+  }
+
+  refreshGhostSuggestion(): void {
+    this.scheduleGhostUpdate();
+  }
+
+  clearGhostSuggestion(): void {
+    this.ghostAbort?.abort();
+    this.ghostAbort = null;
+    this.ghost = null;
+  }
+
+  dismissBashModeUi(): void {
+    resetShellHistoryBrowse(this);
+    this.clearGhostSuggestion();
+
+    const cancelAutocomplete = Reflect.get(this, "cancelAutocomplete");
+    if (typeof cancelAutocomplete === "function") {
+      cancelAutocomplete.call(this);
+    }
+    this.tui.requestRender();
+  }
+
+  handleInput(data: string): void {
+    const droppedPathText = droppedPathTextFromInput(data);
+    if (droppedPathText !== null) {
+      this.insertTextAtCursor(droppedPathText);
+      resetShellHistoryBrowse(this);
+      if (this.isShellCompletionContext()) {
+        this.scheduleGhostUpdate();
+      } else {
+        this.clearGhostSuggestion();
+      }
+      return;
+    }
+
+    const pasteInProgress =
+      data.includes("\x1b[200~") || Reflect.get(this, "isInPaste") === true;
+    if (pasteInProgress) {
+      super.handleInput(data);
+      if (Reflect.get(this, "isInPaste") === true) {
+        return;
+      }
+    } else {
+      const bashMode = this.optionsRef.isBashModeActive();
+      const oneOffBashCommand = !bashMode && this.isOneOffBashCommandContext();
+
+      if (isCommandUndoShortcut(data)) {
+        const undo = Reflect.get(this, "undo");
+        if (typeof undo === "function") {
+          undo.call(this);
+        }
+        resetShellHistoryBrowse(this);
+        if (this.isShellCompletionContext()) {
+          this.scheduleGhostUpdate();
+        } else {
+          this.clearGhostSuggestion();
+        }
+        return;
+      }
+
+      if (bashMode && this.keybindingsRef.matches(data, "app.interrupt")) {
+        this.optionsRef.onExitBashMode();
+        return;
+      }
+
+      if (
+        bashMode &&
+        this.keybindingsRef.matches(data, "app.clear") &&
+        this.optionsRef.isShellRunning()
+      ) {
+        this.optionsRef.onInterrupt();
+        return;
+      }
+
+      if (
+        bashMode &&
+        this.keybindingsRef.matches(data, "tui.editor.cursorUp")
+      ) {
+        this.navigateShellHistory(-1);
+        return;
+      }
+
+      if (
+        bashMode &&
+        this.keybindingsRef.matches(data, "tui.editor.cursorDown")
+      ) {
+        this.navigateShellHistory(1);
+        return;
+      }
+
+      const editorBoundaryShortcuts =
+        this.optionsRef.editorBoundaryShortcuts ??
+        DEFAULT_EDITOR_BOUNDARY_SHORTCUTS;
+      if (
+        !isKeyRelease(data) &&
+        matchesConfiguredShortcut(data, editorBoundaryShortcuts.start)
+      ) {
+        this.moveCursorToEditorBoundary("start");
+        return;
+      }
+
+      if (
+        !isKeyRelease(data) &&
+        matchesConfiguredShortcut(data, editorBoundaryShortcuts.end)
+      ) {
+        this.moveCursorToEditorBoundary("end");
+        return;
+      }
+
+      if (
+        (bashMode || oneOffBashCommand) &&
+        this.keybindingsRef.matches(data, "tui.input.tab")
+      ) {
+        this.acceptGhostSuggestion();
+        return;
+      }
+
+      if (
+        (bashMode || oneOffBashCommand) &&
+        this.keybindingsRef.matches(data, "tui.editor.cursorRight") &&
+        this.acceptGhostSuggestion()
+      ) {
+        return;
+      }
+
+      if (
+        !bashMode &&
+        matchesKey(data, "up") &&
+        this.isPromptHistoryRecallPosition()
+      ) {
+        const navigateHistory = Reflect.get(this, "navigateHistory");
+        if (typeof navigateHistory === "function") {
+          if (Reflect.get(this, "historyIndex") === -1) {
+            this.promptHistoryDraft = this.getText();
+          }
+          navigateHistory.call(this, -1);
+          return;
+        }
+      }
+
+      if (
+        !bashMode &&
+        matchesKey(data, "down") &&
+        Reflect.get(this, "historyIndex") > -1
+      ) {
+        const isOnLastVisualLine = Reflect.get(this, "isOnLastVisualLine");
+        if (
+          typeof isOnLastVisualLine !== "function" ||
+          isOnLastVisualLine.call(this)
+        ) {
+          const navigateHistory = Reflect.get(this, "navigateHistory");
+          if (typeof navigateHistory === "function") {
+            navigateHistory.call(this, 1);
+            if (
+              Reflect.get(this, "historyIndex") === -1 &&
+              this.promptHistoryDraft !== null
+            ) {
+              const draft = this.promptHistoryDraft;
+              this.promptHistoryDraft = null;
+              const setTextInternal = Reflect.get(this, "setTextInternal");
+              if (typeof setTextInternal === "function") {
+                setTextInternal.call(this, draft);
+              } else {
+                this.setText(draft);
+              }
+            }
+            return;
+          }
+        }
+      }
+
+      if (
+        bashMode &&
+        this.keybindingsRef.matches(data, "tui.input.submit") &&
+        !this.keybindingsRef.matches(data, "tui.input.newLine")
+      ) {
+        if (this.optionsRef.isShellRunning()) {
+          this.optionsRef.onNotify("Shell command already running", "warning");
+          return;
+        }
+
+        const command = this.getExpandedText().trim();
+        if (!command) return;
+        this.clearGhostSuggestion();
+        resetShellHistoryBrowse(this);
+        this.optionsRef.onEditorSubmit?.();
+        this.optionsRef.onSubmitCommand(command);
+        this.setText("");
+        this.refreshGhostSuggestion();
+        return;
+      }
+
+      super.handleInput(data);
+    }
+
+    if (!this.isShellCompletionContext()) {
+      resetShellHistoryBrowse(this);
+      this.clearGhostSuggestion();
+      return;
+    }
+
+    if (
+      pasteInProgress ||
+      isPrintableInput(data) ||
+      this.keybindingsRef.matches(data, "tui.editor.deleteCharBackward") ||
+      this.keybindingsRef.matches(data, "tui.editor.deleteCharForward") ||
+      this.keybindingsRef.matches(data, "tui.editor.deleteWordBackward") ||
+      this.keybindingsRef.matches(data, "tui.editor.deleteWordForward") ||
+      this.keybindingsRef.matches(data, "tui.editor.deleteToLineStart") ||
+      this.keybindingsRef.matches(data, "tui.editor.deleteToLineEnd") ||
+      this.keybindingsRef.matches(data, "tui.input.newLine") ||
+      this.keybindingsRef.matches(data, "tui.editor.cursorLeft") ||
+      this.keybindingsRef.matches(data, "tui.editor.cursorRight")
+    ) {
+      resetShellHistoryBrowse(this);
+      this.scheduleGhostUpdate();
+    }
+  }
+
+  render(width: number): string[] {
+    const lines = super.render(width);
+    if (!this.isShellCompletionContext()) return lines;
+    if (!this.ghost) return lines;
+
+    return (
+      overlayGhostSuggestion(
+        lines,
+        width,
+        this.getText(),
+        this.ghost,
+        this.getCursor(),
+      ) ?? lines
+    );
+  }
+
+  private isShellCompletionContext(): boolean {
+    return (
+      this.optionsRef.isBashModeActive() || this.isOneOffBashCommandContext()
+    );
+  }
+
+  private isOneOffBashCommandContext(): boolean {
+    return getOneOffBashCommandContext(this.getExpandedText()) !== null;
+  }
+
+  private moveCursorToEditorBoundary(position: "start" | "end"): void {
+    const state = Reflect.get(this, "state");
+    const lines =
+      state && typeof state === "object" ? Reflect.get(state, "lines") : null;
+    if (!Array.isArray(lines)) {
+      throw new Error("Editor cursor state is unavailable");
+    }
+
+    if (position === "start") {
+      Reflect.set(state, "cursorLine", 0);
+      Reflect.set(state, "cursorCol", 0);
+    } else {
+      const lastLine = Math.max(0, lines.length - 1);
+      Reflect.set(state, "cursorLine", lastLine);
+      Reflect.set(
+        state,
+        "cursorCol",
+        typeof lines[lastLine] === "string" ? lines[lastLine].length : 0,
+      );
+    }
+
+    Reflect.set(this, "lastAction", null);
+    Reflect.set(this, "preferredVisualCol", null);
+    Reflect.set(this, "snappedFromCursorCol", null);
+    this.tui.requestRender();
+  }
+
+  private acceptGhostSuggestion(): boolean {
+    if (!this.ghost) return false;
+    const text = this.getExpandedText();
+    if (text.includes("\n")) return false;
+
+    const cursor = this.getCursor();
+    if (cursor.line !== 0 || cursor.col !== text.length) return false;
+
+    if (!this.ghost.value.startsWith(text) || this.ghost.value === text)
+      return false;
+    this.setText(this.ghost.value);
+    this.clearGhostSuggestion();
+    return true;
+  }
+
+  private isPromptHistoryRecallPosition(): boolean {
+    if (this.isShowingAutocomplete()) return false;
+
+    const history = Reflect.get(this, "history");
+    if (!Array.isArray(history) || history.length === 0) return false;
+
+    const lines = this.getLines();
+    const cursor = this.getCursor();
+    if (lines.length === 1) {
+      return cursor.line === 0 && cursor.col === (lines[0]?.length ?? 0);
+    }
+
+    const isOnFirstVisualLine = Reflect.get(this, "isOnFirstVisualLine");
+    if (
+      typeof isOnFirstVisualLine === "function" &&
+      !isOnFirstVisualLine.call(this)
+    ) {
+      return false;
+    }
+
+    return cursor.line === 0;
+  }
+
+  private navigateShellHistory(direction: -1 | 1): void {
+    const prefix = this.shellHistoryDraft || this.getExpandedText();
+    if (this.shellHistoryIndex === -1) {
+      this.shellHistoryDraft = prefix;
+      this.shellHistoryItems = this.optionsRef.getHistoryEntries(prefix);
+    }
+
+    if (this.shellHistoryItems.length === 0) {
+      this.optionsRef.onNotify("No shell history matches", "info");
+      return;
+    }
+
+    if (direction < 0) {
+      this.shellHistoryIndex = Math.min(
+        this.shellHistoryItems.length - 1,
+        this.shellHistoryIndex + 1,
+      );
+      this.setText(
+        this.shellHistoryItems[this.shellHistoryIndex] ??
+          this.shellHistoryDraft,
+      );
+      this.clearGhostSuggestion();
+      return;
+    }
+
+    this.shellHistoryIndex -= 1;
+    if (this.shellHistoryIndex < 0) {
+      this.shellHistoryIndex = -1;
+      this.setText(this.shellHistoryDraft);
+      this.scheduleGhostUpdate();
+      return;
+    }
+
+    this.setText(
+      this.shellHistoryItems[this.shellHistoryIndex] ?? this.shellHistoryDraft,
+    );
+    this.clearGhostSuggestion();
+  }
+
+  private scheduleGhostUpdate(): void {
+    const text = this.getExpandedText();
+    const currentToken = ++this.ghostToken;
+    this.ghostAbort?.abort();
+
+    const controller = new AbortController();
+    this.ghostAbort = controller;
+    this.optionsRef
+      .resolveGhostSuggestion(text, controller.signal)
+      .then((ghost) => {
+        if (controller.signal.aborted || currentToken !== this.ghostToken)
+          return;
+        this.ghost = ghost;
+        this.tui.requestRender();
+      })
+      .catch((error) => {
+        if (error instanceof Error && error.message === "aborted") return;
+        console.debug(
+          "[powerline-footer] Failed to resolve bash ghost suggestion:",
+          error,
+        );
+      });
+  }
+}

package/bash-mode/history.ts

@@ -0,0 +1,263 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentPath, getHomeDir } from "../src/paths/agent-dirs.ts";
+
+interface PersistedHistoryEntry {
+  command: string;
+  cwd: string;
+  timestamp: number;
+}
+
+// mode and ctimeMs are part of the fingerprint so permission/ACL transitions
+// (e.g. chmod 000) invalidate the cache even when content is unchanged.
+interface FileFingerprint {
+  ctimeMs: number;
+  mtimeMs: number;
+  mode: number;
+  size: number;
+}
+
+interface CachedHistory<T> extends FileFingerprint {
+  entries: T;
+}
+
+function matchesFingerprint(
+  cached: FileFingerprint,
+  stat: FileFingerprint,
+): boolean {
+  return (
+    cached.ctimeMs === stat.ctimeMs &&
+    cached.mtimeMs === stat.mtimeMs &&
+    cached.mode === stat.mode &&
+    cached.size === stat.size
+  );
+}
+
+const projectHistoryCache = new Map<
+  string,
+  CachedHistory<PersistedHistoryEntry[]>
+>();
+const globalHistoryCache = new Map<string, CachedHistory<string[]>>();
+
+function getHistoryDir(): string {
+  return getAgentPath("powerline-footer", "bash-history");
+}
+
+function projectKey(cwd: string): string {
+  return cwd.replace(/^[/\\]+|[/\\]+$/g, "").replace(/[\\/]+/g, "-") || "root";
+}
+
+function projectHistoryPath(cwd: string): string {
+  return join(getHistoryDir(), `${projectKey(cwd)}.json`);
+}
+
+function normalizePersistedEntries(value: unknown): PersistedHistoryEntry[] {
+  if (!Array.isArray(value)) return [];
+
+  const entries: PersistedHistoryEntry[] = [];
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+      continue;
+    const command =
+      typeof entry.command === "string" ? entry.command.trim() : "";
+    const cwd = typeof entry.cwd === "string" ? entry.cwd.trim() : "";
+    const timestamp =
+      typeof entry.timestamp === "number" && Number.isFinite(entry.timestamp)
+        ? entry.timestamp
+        : 0;
+    if (!command || !cwd || !timestamp) continue;
+    entries.push({ command, cwd, timestamp });
+  }
+  return entries;
+}
+
+export function readProjectHistory(cwd: string): PersistedHistoryEntry[] {
+  const filePath = projectHistoryPath(cwd);
+  if (!existsSync(filePath)) {
+    projectHistoryCache.delete(filePath);
+    return [];
+  }
+
+  try {
+    const stat = statSync(filePath);
+    const cached = projectHistoryCache.get(filePath);
+    if (cached && matchesFingerprint(cached, stat)) {
+      return cached.entries;
+    }
+
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return [];
+    const entries = normalizePersistedEntries(
+      (parsed as { entries?: unknown }).entries,
+    ).sort((a, b) => b.timestamp - a.timestamp);
+    projectHistoryCache.set(filePath, {
+      ctimeMs: stat.ctimeMs,
+      mtimeMs: stat.mtimeMs,
+      mode: stat.mode,
+      size: stat.size,
+      entries,
+    });
+    return entries;
+  } catch (error) {
+    // Project history is a best-effort cache. If it is unreadable or malformed,
+    // bash mode should keep working instead of failing command entry entirely.
+    console.debug(
+      `[powerline-footer] Failed to read bash project history from ${filePath}:`,
+      error,
+    );
+    return [];
+  }
+}
+
+export function appendProjectHistory(
+  cwd: string,
+  command: string,
+  entryCwd: string,
+): void {
+  const normalizedCommand = command.trim();
+  if (!normalizedCommand) return;
+
+  const existing = readProjectHistory(cwd);
+  const next: PersistedHistoryEntry[] = [
+    { command: normalizedCommand, cwd: entryCwd, timestamp: Date.now() },
+    ...existing.filter((entry) => entry.command !== normalizedCommand),
+  ]
+    .slice(0, 500)
+    .sort((a, b) => b.timestamp - a.timestamp);
+
+  const filePath = projectHistoryPath(cwd);
+  projectHistoryCache.delete(filePath);
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(
+      filePath,
+      JSON.stringify({ version: 1, entries: next }, null, 2) + "\n",
+    );
+    const stat = statSync(filePath);
+    projectHistoryCache.set(filePath, {
+      ctimeMs: stat.ctimeMs,
+      mtimeMs: stat.mtimeMs,
+      mode: stat.mode,
+      size: stat.size,
+      entries: next,
+    });
+  } catch (error) {
+    // History persistence should never block a successful shell command from completing.
+    console.debug(
+      `[powerline-footer] Failed to persist bash project history to ${filePath}:`,
+      error,
+    );
+  }
+}
+
+function parseZshHistoryLine(line: string): string | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  if (!trimmed.startsWith(":")) return trimmed;
+  const parts = trimmed.split(";");
+  if (parts.length < 2) return null;
+  return parts.slice(1).join(";").trim() || null;
+}
+
+function parseBashHistory(lines: string[]): string[] {
+  return lines.map((line) => line.trim()).filter(Boolean);
+}
+
+function parseFishHistory(raw: string): string[] {
+  const matches = raw.matchAll(/^\s*-\s*cmd:\s*(.+)$/gm);
+  const commands: string[] = [];
+  for (const match of matches) {
+    const command = match[1]?.trim();
+    if (command) commands.push(command);
+  }
+  return commands;
+}
+
+export function readGlobalShellHistory(shellPath: string): string[] {
+  const shellName = shellPath.split("/").pop()?.toLowerCase() ?? "";
+  const home = getHomeDir();
+  const filePath = shellName.includes("fish")
+    ? join(home, ".local", "share", "fish", "fish_history")
+    : process.env.HISTFILE ||
+      join(home, shellName.includes("zsh") ? ".zsh_history" : ".bash_history");
+  const cacheKey = `${shellName}\0${filePath}`;
+
+  if (!existsSync(filePath)) {
+    globalHistoryCache.delete(cacheKey);
+    return [];
+  }
+
+  let stat: FileFingerprint | undefined;
+  try {
+    stat = statSync(filePath);
+    const cached = globalHistoryCache.get(cacheKey);
+    if (cached && matchesFingerprint(cached, stat)) {
+      return cached.entries;
+    }
+
+    const raw = readFileSync(filePath, "utf8");
+    const entries = shellName.includes("zsh")
+      ? raw
+          .split("\n")
+          .map(parseZshHistoryLine)
+          .filter((entry): entry is string => Boolean(entry))
+          .reverse()
+      : shellName.includes("fish")
+        ? parseFishHistory(raw).reverse()
+        : parseBashHistory(raw.split("\n")).reverse();
+    globalHistoryCache.set(cacheKey, {
+      ctimeMs: stat.ctimeMs,
+      mtimeMs: stat.mtimeMs,
+      mode: stat.mode,
+      size: stat.size,
+      entries,
+    });
+    return entries;
+  } catch (error) {
+    // Global shell history is optional recall data. If the file exists but is
+    // unreadable, cache an empty result under its fingerprint so bash mode keeps
+    // working without logging a stack on every keypress until the file changes.
+    // Only cache persistent permission failures. Transient filesystem errors
+    // must be retried on the next completion rather than hiding history.
+    const errorCode =
+      error && typeof error === "object" && "code" in error
+        ? (error as { code?: string }).code
+        : undefined;
+    if (stat && (errorCode === "EACCES" || errorCode === "EPERM")) {
+      globalHistoryCache.set(cacheKey, { ...stat, entries: [] });
+    }
+    console.debug(
+      `[powerline-footer] Failed to read global shell history for ${shellName}:`,
+      error,
+    );
+    return [];
+  }
+}
+
+export function matchHistoryEntries(
+  entries: string[],
+  prefix: string,
+  limit: number,
+): string[] {
+  const trimmedPrefix = prefix.trim();
+  const seen = new Set<string>();
+  const matches: string[] = [];
+
+  for (const rawEntry of entries) {
+    const entry = rawEntry?.trim();
+    if (!entry || seen.has(entry)) continue;
+    if (trimmedPrefix && !entry.startsWith(trimmedPrefix)) continue;
+    seen.add(entry);
+    matches.push(entry);
+    if (matches.length >= limit) break;
+  }
+
+  return matches;
+}