pi-session-cleanup 1.0.0

package/src/types-shims.d.ts

@@ -0,0 +1,192 @@
+declare namespace NodeJS {
+  interface Process {
+    env: Record<string, string | undefined>;
+    platform: string;
+    stdout: {
+      columns?: number;
+      rows?: number;
+    };
+  }
+}
+
+declare const process: NodeJS.Process;
+
+declare module "node:assert/strict" {
+  const assert: {
+    equal(actual: unknown, expected: unknown, message?: string): void;
+    deepEqual(actual: unknown, expected: unknown, message?: string): void;
+    ok(value: unknown, message?: string): void;
+  };
+
+  export default assert;
+}
+
+declare module "node:child_process" {
+  export function spawnSync(
+    command: string,
+    args?: readonly string[],
+    options?: Record<string, unknown>,
+  ): {
+    status: number | null;
+    stderr?: unknown;
+    error?: Error;
+  };
+}
+
+declare module "node:fs" {
+  export function existsSync(path: string): boolean;
+  export function mkdirSync(path: string, options?: { recursive?: boolean }): void;
+  export function mkdtempSync(prefix: string): string;
+  export function readFileSync(path: string, encoding: string): string;
+  export function rmSync(path: string, options?: { recursive?: boolean; force?: boolean }): void;
+  export function writeFileSync(path: string, data: string, encoding: string): void;
+}
+
+declare module "node:fs/promises" {
+  export function readFile(path: string, encoding: string): Promise<string>;
+  export function unlink(path: string): Promise<void>;
+}
+
+declare module "node:os" {
+  export function homedir(): string;
+  export function tmpdir(): string;
+}
+
+declare module "node:path" {
+  export function basename(path: string): string;
+  export function dirname(path: string): string;
+  export function join(...parts: string[]): string;
+}
+
+declare module "node:test" {
+  const test: (
+    name: string,
+    fn: (context?: unknown) => void | Promise<void>,
+  ) => void;
+
+  export default test;
+}
+
+declare module "node:url" {
+  export function fileURLToPath(url: unknown): string;
+}
+
+declare module "@mariozechner/pi-tui" {
+  export interface Component {
+    render(width: number): string[];
+    handleInput(data: string): void;
+    invalidate?(): void;
+  }
+
+  export function matchesKey(data: string, key: string): boolean;
+  export function truncateToWidth(
+    text: string,
+    width: number,
+    ellipsis?: string,
+    trimWhitespace?: boolean,
+  ): string;
+  export function visibleWidth(text: string): number;
+}
+
+declare module "@mariozechner/pi-coding-agent" {
+  import type { Component } from "@mariozechner/pi-tui";
+
+  export interface SessionInfo {
+    path: string;
+    id: string;
+    cwd: string;
+    name?: string;
+    parentSessionPath?: string;
+    created: Date;
+    modified: Date;
+    messageCount: number;
+    firstMessage: string;
+    allMessagesText: string;
+  }
+
+  export class SessionManager {
+    static list(cwd: string, sessionDir: string): Promise<SessionInfo[]>;
+    static listAll(): Promise<SessionInfo[]>;
+    getSessionId(): string;
+    getSessionFile(): string | undefined;
+    getCwd(): string;
+    getSessionDir(): string;
+    getEntries(): unknown[];
+    getSessionName(): string | undefined;
+  }
+
+  export interface Theme {
+    fg?(color: string, text: string): string;
+    bold?(text: string): string;
+  }
+
+  export interface ExtensionUIContext {
+    select(title: string, options: string[]): Promise<string | undefined>;
+    confirm(title: string, message: string): Promise<boolean>;
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+    custom<T>(
+      factory: (
+        tui: { requestRender(): void },
+        theme: Theme,
+        keybindings: unknown,
+        done: (result?: T) => void,
+      ) => Component,
+      options?: Record<string, unknown>,
+    ): Promise<T>;
+  }
+
+  export interface ExtensionContext {
+    hasUI: boolean;
+    cwd: string;
+    sessionManager: SessionManager;
+    ui: ExtensionUIContext;
+    getSystemPrompt(): string;
+  }
+
+  export interface ExtensionCommandContext extends ExtensionContext {
+    newSession(options?: {
+      parentSession?: string;
+      setup?: (sessionManager: SessionManager) => Promise<void>;
+    }): Promise<{ cancelled: boolean }>;
+    reload(): Promise<void>;
+  }
+
+  export interface ResourcesDiscoverEvent {
+    type: "resources_discover";
+    cwd: string;
+    reason: "startup" | "reload";
+  }
+
+  export interface SessionStartEvent {
+    type: "session_start";
+    cwd: string;
+    reason: "new" | "resume" | "fork" | "reload";
+  }
+
+  export interface ExtensionAPI {
+    on(
+      event: "resources_discover",
+      handler: (event: ResourcesDiscoverEvent) => void | Promise<void>,
+    ): void;
+    on(
+      event: "session_start",
+      handler: (event: SessionStartEvent, ctx: ExtensionContext) => void | Promise<void>,
+    ): void;
+
+    registerCommand(
+      name: string,
+      definition: {
+        description: string;
+        getArgumentCompletions?: (
+          argumentPrefix: string,
+        ) => Array<{ value: string; label: string; description?: string }> | null;
+        handler: (args: string, ctx: ExtensionCommandContext) => Promise<void> | void;
+      },
+    ): void;
+
+    sendUserMessage(
+      content: string,
+      options?: { deliverAs?: "steer" | "followUp" },
+    ): void;
+  }
+}

package/src/types.ts

@@ -0,0 +1,39 @@
+import type { SessionInfo } from "@mariozechner/pi-coding-agent";
+
+export type SessionScope = "current" | "all";
+
+export type DeleteMethod = "trash" | "unlink";
+
+export interface SessionCleanupSession extends SessionInfo {
+  responsibleAgentName: string | null;
+}
+
+export interface DeleteSessionSuccess {
+  ok: true;
+  method: DeleteMethod;
+}
+
+export interface DeleteSessionFailure {
+  ok: false;
+  method: "unlink";
+  error: string;
+}
+
+export type DeleteSessionResult = DeleteSessionSuccess | DeleteSessionFailure;
+
+export interface DeleteFailureDetail {
+  session: SessionInfo;
+  error: string;
+}
+
+export interface BatchDeleteResult {
+  deleted: SessionInfo[];
+  failed: DeleteFailureDetail[];
+  methods: Record<DeleteMethod, number>;
+}
+
+export interface SessionSelectionResult {
+  cancelled: boolean;
+  refreshRequested: boolean;
+  selectedPaths: Set<string>;
+}

package/src/ui/icons.ts

@@ -0,0 +1,476 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { IconModePreference } from "../config-store.js";
+
+export type PickerIconMode = "nerd" | "fallback";
+
+export interface PickerIcons {
+  cursor: string;
+  checkboxChecked: string;
+  checkboxUnchecked: string;
+  scrollUp: string;
+  scrollDown: string;
+  actionMove: string;
+  actionPage: string;
+  actionToggle: string;
+  actionSelectAll: string;
+  actionRefresh: string;
+  actionDelete: string;
+  actionCancel: string;
+}
+
+export interface ResolvedPickerIcons {
+  mode: PickerIconMode;
+  icons: PickerIcons;
+}
+
+export interface PickerIconDetectionContext {
+  platform: string;
+  env: Record<string, string | undefined>;
+  pathExists: (path: string) => boolean;
+  readTextFile: (path: string) => string | null;
+}
+
+const NERD_ICONS: PickerIcons = {
+  cursor: "",
+  checkboxChecked: "",
+  checkboxUnchecked: "",
+  scrollUp: "",
+  scrollDown: "",
+  actionMove: "󰆾",
+  actionPage: "󰘖",
+  actionToggle: "󰄱",
+  actionSelectAll: "󰄬",
+  actionRefresh: "󰑐",
+  actionDelete: "󰆴",
+  actionCancel: "󰜺",
+};
+
+const FALLBACK_ICONS: PickerIcons = {
+  cursor: "›",
+  checkboxChecked: "☑",
+  checkboxUnchecked: "☐",
+  scrollUp: "↑",
+  scrollDown: "↓",
+  actionMove: "↕",
+  actionPage: "⇵",
+  actionToggle: "☑",
+  actionSelectAll: "☑",
+  actionRefresh: "↻",
+  actionDelete: "✖",
+  actionCancel: "✖",
+};
+
+const WINDOWS_TERMINAL_SETTINGS_CANDIDATES = [
+  ["Packages", "Microsoft.WindowsTerminal_8wekyb3d8bbwe", "LocalState", "settings.json"],
+  ["Packages", "Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe", "LocalState", "settings.json"],
+  ["Packages", "Microsoft.WindowsTerminalDev_8wekyb3d8bbwe", "LocalState", "settings.json"],
+  ["Microsoft", "Windows Terminal", "settings.json"],
+] as const;
+
+const KNOWN_NERD_TERM_PROGRAM_HINTS = [
+  "wezterm",
+  "ghostty",
+  "kitty",
+  "iterm",
+  "warpterminal",
+  "warp",
+  "hyper",
+  "alacritty",
+  "konsole",
+] as const;
+
+const KNOWN_NERD_TERM_HINTS = ["xterm-kitty", "wezterm", "ghostty", "alacritty", "konsole"] as const;
+
+const FONT_HINT_ENV_KEYS = [
+  "PI_SESSION_CLEANUP_FONT_FAMILY",
+  "PI_FONT_FAMILY",
+  "TERM_PROGRAM_FONT",
+  "KITTY_FONT_FAMILY",
+  "WEZTERM_FONT",
+  "WT_PROFILE_FONT_FACE",
+] as const;
+
+function createDefaultContext(): PickerIconDetectionContext {
+  return {
+    platform: process.platform,
+    env: process.env,
+    pathExists: (path) => existsSync(path),
+    readTextFile: (path) => {
+      try {
+        return readFileSync(path, "utf8");
+      } catch {
+        return null;
+      }
+    },
+  };
+}
+
+function parseEnvBoolean(value: string | undefined): boolean | null {
+  if (!value) {
+    return null;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+
+  return null;
+}
+
+function parseMode(value: string | undefined): IconModePreference | null {
+  if (!value) {
+    return null;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "auto" || normalized === "nerd" || normalized === "fallback") {
+    return normalized;
+  }
+
+  return null;
+}
+
+function resolvePreference(
+  configPreference: IconModePreference,
+  env: Record<string, string | undefined>,
+): IconModePreference {
+  const envMode = parseMode(env.PI_SESSION_CLEANUP_ICON_MODE);
+  if (envMode) {
+    return envMode;
+  }
+
+  const envBool = parseEnvBoolean(env.PI_SESSION_CLEANUP_NERD_FONT ?? env.PI_NERD_FONT);
+  if (envBool !== null) {
+    return envBool ? "nerd" : "fallback";
+  }
+
+  return configPreference;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function normalizeProfileId(value: string): string {
+  return value.trim().replace(/^\{/, "").replace(/\}$/, "").toLowerCase();
+}
+
+function readWindowsTerminalSettingsJson(
+  settingsPath: string,
+  context: PickerIconDetectionContext,
+): Record<string, unknown> | null {
+  const raw = context.readTextFile(settingsPath);
+  return raw ? parseSettingsJson(raw) : null;
+}
+
+function parseSettingsJson(raw: string): Record<string, unknown> | null {
+  const withoutBom = raw.replace(/^\uFEFF/, "");
+
+  try {
+    const parsed = JSON.parse(withoutBom);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    const withoutComments = stripJsonComments(withoutBom);
+    const withoutTrailingCommas = stripTrailingCommas(withoutComments);
+
+    try {
+      const parsed = JSON.parse(withoutTrailingCommas);
+      return isRecord(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+}
+
+function stripJsonComments(value: string): string {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const current = value[index];
+    const next = value[index + 1];
+
+    if (inLineComment) {
+      if (current === "\n") {
+        inLineComment = false;
+        result += current;
+      }
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (inString) {
+      result += current;
+      if (escaped) {
+        escaped = false;
+      } else if (current === "\\") {
+        escaped = true;
+      } else if (current === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (current === '"') {
+      inString = true;
+      result += current;
+      continue;
+    }
+
+    if (current === "/" && next === "/") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+
+    if (current === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+
+    result += current;
+  }
+
+  return result;
+}
+
+function stripTrailingCommas(value: string): string {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const current = value[index];
+
+    if (inString) {
+      result += current;
+      if (escaped) {
+        escaped = false;
+      } else if (current === "\\") {
+        escaped = true;
+      } else if (current === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (current === '"') {
+      inString = true;
+      result += current;
+      continue;
+    }
+
+    if (current !== ",") {
+      result += current;
+      continue;
+    }
+
+    let lookahead = index + 1;
+    while (lookahead < value.length && /\s/.test(value[lookahead] ?? "")) {
+      lookahead += 1;
+    }
+
+    const nextNonSpace = value[lookahead];
+    if (nextNonSpace === "}" || nextNonSpace === "]") {
+      continue;
+    }
+
+    result += current;
+  }
+
+  return result;
+}
+
+function getRecord(value: unknown, key: string): Record<string, unknown> | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+
+  const nested = value[key];
+  return isRecord(nested) ? nested : null;
+}
+
+function getProfileFontFace(profile: Record<string, unknown> | null): string | null {
+  if (!profile) {
+    return null;
+  }
+
+  const font = getRecord(profile, "font");
+  if (font && typeof font.face === "string" && font.face.trim().length > 0) {
+    return font.face;
+  }
+
+  if (typeof profile.fontFace === "string" && profile.fontFace.trim().length > 0) {
+    return profile.fontFace;
+  }
+
+  return null;
+}
+
+function findProfileById(
+  settings: Record<string, unknown>,
+  wtProfileId: string | undefined,
+): Record<string, unknown> | null {
+  if (!wtProfileId) {
+    return null;
+  }
+
+  const profiles = getRecord(settings, "profiles");
+  const list = profiles?.list;
+  if (!Array.isArray(list)) {
+    return null;
+  }
+
+  const expectedId = normalizeProfileId(wtProfileId);
+  if (expectedId.length === 0) {
+    return null;
+  }
+
+  for (const item of list) {
+    if (!isRecord(item)) {
+      continue;
+    }
+
+    const guid = typeof item.guid === "string" ? normalizeProfileId(item.guid) : "";
+    if (guid === expectedId) {
+      return item;
+    }
+  }
+
+  return null;
+}
+
+function resolveWindowsTerminalSettingsPath(context: PickerIconDetectionContext): string | null {
+  const localAppData = context.env.LOCALAPPDATA;
+  if (!localAppData) {
+    return null;
+  }
+
+  for (const segments of WINDOWS_TERMINAL_SETTINGS_CANDIDATES) {
+    const candidatePath = join(localAppData, ...segments);
+    if (context.pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+
+  return null;
+}
+
+function isNerdFontFace(fontFace: string | null): boolean {
+  return typeof fontFace === "string" && /nerd/i.test(fontFace);
+}
+
+function detectFontHintFromEnv(env: Record<string, string | undefined>): boolean {
+  for (const key of FONT_HINT_ENV_KEYS) {
+    if (isNerdFontFace(env[key] ?? null)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function detectKnownTerminalHint(env: Record<string, string | undefined>): boolean {
+  if (env.GHOSTTY_RESOURCES_DIR || env.WEZTERM_EXECUTABLE || env.WEZTERM_PANE || env.KITTY_WINDOW_ID) {
+    return true;
+  }
+
+  const termProgram = (env.TERM_PROGRAM ?? "").trim().toLowerCase();
+  if (KNOWN_NERD_TERM_PROGRAM_HINTS.some((hint) => termProgram.includes(hint))) {
+    return true;
+  }
+
+  const term = (env.TERM ?? "").trim().toLowerCase();
+  return KNOWN_NERD_TERM_HINTS.some((hint) => term.includes(hint));
+}
+
+function detectWindowsTerminalNerdFont(context: PickerIconDetectionContext): boolean {
+  if (!context.env.WT_SESSION) {
+    return false;
+  }
+
+  const settingsPath = resolveWindowsTerminalSettingsPath(context);
+  if (!settingsPath) {
+    return false;
+  }
+
+  const settings = readWindowsTerminalSettingsJson(settingsPath, context);
+  if (!settings) {
+    return false;
+  }
+
+  const activeProfile = findProfileById(settings, context.env.WT_PROFILE_ID);
+  const activeProfileFont = getProfileFontFace(activeProfile);
+  if (activeProfileFont !== null) {
+    return isNerdFontFace(activeProfileFont);
+  }
+
+  const profiles = getRecord(settings, "profiles");
+  const profileDefaultsFont = getProfileFontFace(getRecord(profiles, "defaults"));
+  if (profileDefaultsFont !== null) {
+    return isNerdFontFace(profileDefaultsFont);
+  }
+
+  const rootDefaultsFont = getProfileFontFace(getRecord(settings, "defaults"));
+  if (rootDefaultsFont !== null) {
+    return isNerdFontFace(rootDefaultsFont);
+  }
+
+  return false;
+}
+
+function resolveAutoMode(context: PickerIconDetectionContext): PickerIconMode {
+  if (context.platform === "win32" && detectWindowsTerminalNerdFont(context)) {
+    return "nerd";
+  }
+
+  if (detectFontHintFromEnv(context.env) || detectKnownTerminalHint(context.env)) {
+    return "nerd";
+  }
+
+  return "fallback";
+}
+
+function iconsForMode(mode: PickerIconMode): PickerIcons {
+  return mode === "nerd" ? NERD_ICONS : FALLBACK_ICONS;
+}
+
+export function resolvePickerIconsForContext(
+  configPreference: IconModePreference,
+  context: PickerIconDetectionContext,
+): ResolvedPickerIcons {
+  const preference = resolvePreference(configPreference, context.env);
+  const mode =
+    preference === "auto"
+      ? resolveAutoMode(context)
+      : preference === "nerd"
+        ? "nerd"
+        : "fallback";
+
+  return {
+    mode,
+    icons: iconsForMode(mode),
+  };
+}
+
+export function resolvePickerIcons(configPreference: IconModePreference): ResolvedPickerIcons {
+  return resolvePickerIconsForContext(configPreference, createDefaultContext());
+}

package/src/ui/legend.ts

@@ -0,0 +1,15 @@
+import type { PickerIcons } from "./icons.js";
+
+export interface LegendContent {
+  lines: string[];
+}
+
+export function buildLegendContent(_icons: PickerIcons, _maxWidth: number): LegendContent {
+  return {
+    lines: [
+      "NAV: [↑/↓/j/k] Move  [PgUp/PgDn] Page",
+      "SEL: [Space] Toggle  [a] Select All",
+      "ACT: [Enter] Delete  [r] Refresh  [Esc/q] Cancel",
+    ],
+  };
+}