@selesai/code 0.7.0 → 0.8.1

package/dist/extensions/pi-powerline-footer/bash-mode/editor.ts

@@ -1,15 +1,14 @@
 import { fileURLToPath } from "node:url";
-import { CustomEditor } from "@selesai/code";
+import { CustomEditor, type KeybindingsManager } from "@selesai/code";
 import { isKeyRelease, matchesKey, visibleWidth, truncateToWidth } from "@earendil-works/pi-tui";
-import type { KeybindingsManager } from "@selesai/code/dist/core/keybindings.js";
 import type { AutocompleteProvider } from "@earendil-works/pi-tui";
 import { matchesConfiguredShortcut } from "../shortcuts.ts";
 import { getOneOffBashCommandContext } from "./completion.ts";
 import type { GhostSuggestion } from "./types.ts";
 
 interface EditorBoundaryShortcuts {
-  start: string;
-  end: string;
+  start: string | null;
+  end: string | null;
 }
 
 interface BashModeEditorOptions {
@@ -89,6 +88,12 @@ function droppedPathTextFromInput(data: string): string | null {
   return null;
 }
 
+function resetShellHistoryBrowse(state: object): void {
+  Reflect.set(state, "shellHistoryIndex", -1);
+  Reflect.set(state, "shellHistoryItems", []);
+  Reflect.set(state, "shellHistoryDraft", "");
+}
+
 export class BashModeEditor extends CustomEditor {
   private readonly keybindingsRef: KeybindingsManager;
   private readonly optionsRef: BashModeEditorOptions;
@@ -96,6 +101,7 @@ export class BashModeEditor extends CustomEditor {
   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;
@@ -106,6 +112,11 @@ export class BashModeEditor extends CustomEditor {
     this.optionsRef = options;
   }
 
+  setAutocompleteProvider(provider: AutocompleteProvider): void {
+    super.setAutocompleteProvider(provider);
+    this.wrappedProviderInstalled = false;
+  }
+
   installAutocompleteProvider(provider: AutocompleteProvider): void {
     this.setAutocompleteProvider(provider);
     this.wrappedProviderInstalled = true;
@@ -130,13 +141,12 @@ export class BashModeEditor extends CustomEditor {
   }
 
   dismissBashModeUi(): void {
-    this.shellHistoryIndex = -1;
-    this.shellHistoryItems = [];
-    this.shellHistoryDraft = "";
+    resetShellHistoryBrowse(this);
     this.clearGhostSuggestion();
 
-    if ("cancelAutocomplete" in this && typeof this.cancelAutocomplete === "function") {
-      this.cancelAutocomplete();
+    const cancelAutocomplete = Reflect.get(this, "cancelAutocomplete");
+    if (typeof cancelAutocomplete === "function") {
+      cancelAutocomplete.call(this);
     }
     this.tui.requestRender();
   }
@@ -145,9 +155,7 @@ export class BashModeEditor extends CustomEditor {
     const droppedPathText = droppedPathTextFromInput(data);
     if (droppedPathText !== null) {
       this.insertTextAtCursor(droppedPathText);
-      this.shellHistoryIndex = -1;
-      this.shellHistoryItems = [];
-      this.shellHistoryDraft = "";
+      resetShellHistoryBrowse(this);
       if (this.isShellCompletionContext()) {
         this.scheduleGhostUpdate();
       } else {
@@ -167,10 +175,11 @@ export class BashModeEditor extends CustomEditor {
       const oneOffBashCommand = !bashMode && this.isOneOffBashCommandContext();
 
       if (isCommandUndoShortcut(data)) {
-        this.undo();
-        this.shellHistoryIndex = -1;
-        this.shellHistoryItems = [];
-        this.shellHistoryDraft = "";
+        const undo = Reflect.get(this, "undo");
+        if (typeof undo === "function") {
+          undo.call(this);
+        }
+        resetShellHistoryBrowse(this);
         if (this.isShellCompletionContext()) {
           this.scheduleGhostUpdate();
         } else {
@@ -223,6 +232,38 @@ export class BashModeEditor extends CustomEditor {
         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");
@@ -232,9 +273,7 @@ export class BashModeEditor extends CustomEditor {
         const command = this.getExpandedText().trim();
         if (!command) return;
         this.clearGhostSuggestion();
-        this.shellHistoryIndex = -1;
-        this.shellHistoryItems = [];
-        this.shellHistoryDraft = "";
+        resetShellHistoryBrowse(this);
         this.optionsRef.onEditorSubmit?.();
         this.optionsRef.onSubmitCommand(command);
         this.setText("");
@@ -246,9 +285,7 @@ export class BashModeEditor extends CustomEditor {
     }
 
     if (!this.isShellCompletionContext()) {
-      this.shellHistoryIndex = -1;
-      this.shellHistoryItems = [];
-      this.shellHistoryDraft = "";
+      resetShellHistoryBrowse(this);
       this.clearGhostSuggestion();
       return;
     }
@@ -267,9 +304,7 @@ export class BashModeEditor extends CustomEditor {
       || this.keybindingsRef.matches(data, "tui.editor.cursorLeft")
       || this.keybindingsRef.matches(data, "tui.editor.cursorRight")
     ) {
-      this.shellHistoryIndex = -1;
-      this.shellHistoryItems = [];
-      this.shellHistoryDraft = "";
+      resetShellHistoryBrowse(this);
       this.scheduleGhostUpdate();
     }
   }
@@ -345,6 +380,26 @@ export class BashModeEditor extends CustomEditor {
     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) {

package/dist/extensions/pi-powerline-footer/bash-mode/history.ts

@@ -1,7 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-import { getAgentDir } from "@selesai/code";
+import { getAgentPath, getHomeDir } from "../paths.ts";
 
 interface PersistedHistoryEntry {
   command: string;
@@ -9,12 +8,31 @@ interface PersistedHistoryEntry {
   timestamp: number;
 }
 
-function getHomeDir(): string {
-  return process.env.HOME || process.env.USERPROFILE || homedir();
+// 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 join(getAgentDir(), "powerline-footer", "bash-history");
+  return getAgentPath("powerline-footer", "bash-history");
 }
 
 function projectKey(cwd: string): string {
@@ -44,13 +62,30 @@ function normalizePersistedEntries(value: unknown): PersistedHistoryEntry[] {
 
 export function readProjectHistory(cwd: string): PersistedHistoryEntry[] {
   const filePath = projectHistoryPath(cwd);
-  if (!existsSync(filePath)) return [];
+  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 [];
-    return normalizePersistedEntries((parsed as { entries?: unknown }).entries)
+    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.
@@ -67,12 +102,23 @@ export function appendProjectHistory(cwd: string, command: string, entryCwd: str
   const next: PersistedHistoryEntry[] = [
     { command: normalizedCommand, cwd: entryCwd, timestamp: Date.now() },
     ...existing.filter((entry) => entry.command !== normalizedCommand),
-  ].slice(0, 500);
+  ]
+    .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);
@@ -105,31 +151,37 @@ function parseFishHistory(raw: string): string[] {
 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}`;
 
-  try {
-    if (shellName.includes("zsh")) {
-      const filePath = process.env.HISTFILE || join(home, ".zsh_history");
-      if (!existsSync(filePath)) return [];
-      return readFileSync(filePath, "utf8")
-        .split("\n")
-        .map(parseZshHistoryLine)
-        .filter((entry): entry is string => Boolean(entry))
-        .reverse();
-    }
+  if (!existsSync(filePath)) {
+    globalHistoryCache.delete(cacheKey);
+    return [];
+  }
 
-    if (shellName.includes("fish")) {
-      const filePath = join(home, ".local", "share", "fish", "fish_history");
-      if (!existsSync(filePath)) return [];
-      return parseFishHistory(readFileSync(filePath, "utf8")).reverse();
+  let stat: FileFingerprint | undefined;
+  try {
+    stat = statSync(filePath);
+    const cached = globalHistoryCache.get(cacheKey);
+    if (cached && matchesFingerprint(cached, stat)) {
+      return cached.entries;
     }
 
-    const filePath = process.env.HISTFILE || join(home, ".bash_history");
-    if (!existsSync(filePath)) return [];
-    return parseBashHistory(readFileSync(filePath, "utf8").split("\n")).reverse();
+    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, { ...stat, entries });
+    return entries;
   } catch (error) {
-    // Global shell history is optional recall data. If it is unavailable, shell predictions
-    // should degrade to other sources instead of failing the editor.
-    console.debug(`[powerline-footer] Failed to read global shell history for ${shellName}:`, error);
+    if (stat) {
+      globalHistoryCache.set(cacheKey, { ...stat, entries: [] });
+      console.debug(`[powerline-footer] Failed to read global shell history for ${shellName}:`, error);
+    }
     return [];
   }
 }

package/dist/extensions/pi-powerline-footer/bash-mode/types.ts

@@ -1,5 +1,5 @@
 export interface BashModeSettings {
-  toggleShortcut: string;
+  toggleShortcut: string | null;
   transcriptMaxLines: number;
   transcriptMaxBytes: number;
 }

package/dist/extensions/pi-powerline-footer/cd-command.ts

@@ -0,0 +1,190 @@
+import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { SessionManager, type ExtensionAPI, type ExtensionCommandContext } from "@selesai/code";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+function stripMatchingQuotes(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2) {
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return trimmed.slice(1, -1);
+    }
+  }
+  return trimmed;
+}
+
+function unescapePathArg(value: string): string {
+  return stripMatchingQuotes(value).replace(/\\(.)/g, "$1");
+}
+
+function expandHomePath(value: string, homeDir = homedir()): string {
+  if (value === "~") return homeDir;
+  if (value.startsWith("~/")) return join(homeDir, value.slice(2));
+  return value;
+}
+
+function escapeCompletionPath(value: string): string {
+  return value.replace(/([\\\s"'`$&|;<>()[\]{}?!*])/g, "\\$1");
+}
+
+function displayPath(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+export function resolveCdTarget(args: string, cwd: string, homeDir = homedir()): { path: string } | { error: string } | null {
+  const input = unescapePathArg(args);
+  if (!input) return null;
+
+  const expanded = expandHomePath(input, homeDir);
+  const target = isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+
+  if (!existsSync(target)) {
+    return { error: `Directory does not exist: ${target}` };
+  }
+
+  try {
+    if (!statSync(target).isDirectory()) {
+      return { error: `Not a directory: ${target}` };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { error: `Cannot access directory: ${message}` };
+  }
+
+  return { path: target };
+}
+
+function pathBase(token: string, cwd: string, homeDir: string): { dir: string; prefix: string; displayPrefix: string } {
+  const unescaped = unescapePathArg(token);
+  const expanded = expandHomePath(unescaped, homeDir);
+  const hasSlash = expanded.includes("/");
+
+  if (!hasSlash) {
+    return { dir: cwd, prefix: expanded, displayPrefix: "" };
+  }
+
+  const baseDir = expanded.endsWith("/") ? expanded.slice(0, -1) : dirname(expanded);
+  const dir = isAbsolute(baseDir) ? baseDir : resolve(cwd, baseDir);
+  const prefix = expanded.endsWith("/") ? "" : basename(expanded);
+  const displayPrefix = unescaped.endsWith("/") ? unescaped : unescaped.slice(0, Math.max(0, unescaped.length - prefix.length));
+  return { dir, prefix, displayPrefix };
+}
+
+function isDirectoryEntry(dir: string, name: string): boolean {
+  try {
+    return statSync(join(dir, name)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function getCdArgumentCompletions(argumentPrefix: string, cwd: string, homeDir = homedir()): AutocompleteItem[] {
+  const prefix = argumentPrefix.trimStart();
+  const suggestions: AutocompleteItem[] = [];
+
+  for (const quickPick of ["../", "~/"]) {
+    if (!prefix || quickPick.startsWith(prefix)) {
+      suggestions.push({ value: quickPick, label: quickPick, description: quickPick === "../" ? "Parent directory" : "Home directory" });
+    }
+  }
+
+  const { dir, prefix: entryPrefix, displayPrefix } = pathBase(prefix, cwd, homeDir);
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.name.startsWith(entryPrefix) && (entry.isDirectory() || entry.isSymbolicLink() && isDirectoryEntry(dir, entry.name)))
+      .slice(0, 50)
+      .map((entry) => {
+        const path = displayPath(`${displayPrefix}${entry.name}/`);
+        return {
+          value: escapeCompletionPath(path),
+          label: path,
+        } satisfies AutocompleteItem;
+      });
+
+    suggestions.push(...entries);
+  } catch {
+    return suggestions;
+  }
+
+  const seen = new Set<string>();
+  return suggestions.filter((item) => {
+    if (seen.has(item.value)) return false;
+    seen.add(item.value);
+    return true;
+  });
+}
+
+function removeSessionFile(filePath: string | undefined): void {
+  if (!filePath) return;
+  try {
+    unlinkSync(filePath);
+  } catch {
+    // Best-effort cleanup only; the command still reports the cancellation/error.
+  }
+}
+
+export async function runCdCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const resolved = resolveCdTarget(args, ctx.cwd);
+  if (resolved === null) {
+    ctx.ui.notify(ctx.cwd, "info");
+    return;
+  }
+  if ("error" in resolved) {
+    ctx.ui.notify(resolved.error, "error");
+    return;
+  }
+  if (resolved.path === ctx.cwd) {
+    ctx.ui.notify(`Already in ${ctx.cwd}`, "info");
+    return;
+  }
+
+  const sessionFile = ctx.sessionManager.getSessionFile();
+  if (!sessionFile) {
+    ctx.ui.notify("/cd requires a persisted Pi session", "error");
+    return;
+  }
+
+  await ctx.waitForIdle();
+  const nextSession = SessionManager.forkFrom(sessionFile, resolved.path);
+  const nextSessionFile = nextSession.getSessionFile();
+
+  try {
+    const result = await ctx.switchSession(nextSessionFile!, {
+      withSession: async (nextCtx) => {
+        try {
+          process.chdir(nextCtx.cwd);
+          nextCtx.ui.notify(`Changed directory to ${nextCtx.cwd}`, "info");
+          nextCtx.ui.setTitle(`pi - ${basename(nextCtx.cwd) || nextCtx.cwd}`);
+        } catch (error) {
+          console.debug("[powerline-footer] Failed to update process cwd after /cd:", error);
+        }
+      },
+    });
+    if (result.cancelled) {
+      removeSessionFile(nextSessionFile);
+      ctx.ui.notify("Directory change cancelled", "warning");
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+      ctx.ui.notify(`Failed to change directory: ${message}`, "error");
+    } catch {
+      console.debug("[powerline-footer] Failed to report /cd error:", error);
+    }
+  }
+}
+
+export function registerCdCommand(pi: ExtensionAPI, getCwd: () => string): void {
+  pi.registerCommand("cd", {
+    description: "Switch the Pi session working directory",
+    getArgumentCompletions(argumentPrefix) {
+      return getCdArgumentCompletions(argumentPrefix, getCwd());
+    },
+    handler: runCdCommand,
+  });
+}

package/dist/extensions/pi-powerline-footer/colors.ts

@@ -32,10 +32,11 @@ const THEME = {
   path: "#00afaf",        // Teal/cyan
   gitClean: "#5faf5f",    // Green
   accent: "#febc38",      // Orange
+  queue: "#febc38",       // Orange
 };
 
 // Color name to ANSI code mapping
-type ColorName = "sep" | "model" | "path" | "gitClean" | "accent";
+type ColorName = keyof typeof THEME;
 
 function getAnsiCode(color: ColorName): string {
   const value = THEME[color as keyof typeof THEME];