pi-session-cleanup 1.0.0

package/src/session-cleanup-command.ts

@@ -0,0 +1,268 @@
+import type {
+  ExtensionCommandContext,
+  SessionInfo,
+} from "@mariozechner/pi-coding-agent";
+
+import {
+  SESSION_CLEANUP_COMMAND,
+} from "./constants.js";
+import { getSessionTitle } from "./session-format.js";
+import { deleteSessionFile } from "./session-delete.js";
+import { loadSessions } from "./session-source.js";
+import { selectSessionsForCleanup } from "./session-selection.js";
+import type {
+  BatchDeleteResult,
+  SessionCleanupSession,
+  SessionScope,
+} from "./types.js";
+
+const ARG_COMPLETIONS = [
+  {
+    value: "current",
+    label: "current",
+    description: "List sessions from the current working directory only",
+  },
+  {
+    value: "all",
+    label: "all",
+    description: "List sessions across every working directory",
+  },
+  {
+    value: "help",
+    label: "help",
+    description: "Show usage",
+  },
+] as const;
+
+interface ParsedArgs {
+  help: boolean;
+  scope: SessionScope;
+  error?: string;
+}
+
+function usage(): string {
+  return `Usage: /${SESSION_CLEANUP_COMMAND} [current|all]`;
+}
+
+function parseArgs(args: string): ParsedArgs {
+  const normalized = args.trim().toLowerCase();
+  if (!normalized) {
+    return { help: false, scope: "current" };
+  }
+
+  if (normalized === "help") {
+    return { help: true, scope: "current" };
+  }
+
+  if (normalized === "current" || normalized === "all") {
+    return { help: false, scope: normalized };
+  }
+
+  return {
+    help: false,
+    scope: "current",
+    error: `Unknown argument: ${args.trim()}`,
+  };
+}
+
+function buildSelectionSummary(sessions: readonly SessionInfo[]): string {
+  const preview = sessions
+    .slice(0, 6)
+    .map((session) => `- ${getSessionTitle(session)} (${session.id.slice(0, 8)})`)
+    .join("\n");
+  const hiddenCount = Math.max(0, sessions.length - 6);
+
+  if (hiddenCount > 0) {
+    return `${preview}\n- …and ${hiddenCount} more`;
+  }
+
+  return preview;
+}
+
+function buildConfirmationMessage(sessions: readonly SessionInfo[]): string {
+  const noun = sessions.length === 1 ? "session" : "sessions";
+  return `Delete ${sessions.length} selected ${noun}?\n\n${buildSelectionSummary(sessions)}\n\nThis action removes session files. Pi will try trash first, then permanent delete if trash is unavailable.`;
+}
+
+function summarizeFailures(
+  failures: readonly { session: SessionInfo; error: string }[],
+): string {
+  return failures
+    .slice(0, 4)
+    .map(
+      (failure) =>
+        `- ${failure.session.id.slice(0, 8)} (${getSessionTitle(failure.session)}): ${failure.error}`,
+    )
+    .join("\n");
+}
+
+async function deleteSelectedSessions(
+  selectedSessions: readonly SessionInfo[],
+  currentSessionFile: string | undefined,
+): Promise<BatchDeleteResult> {
+  const result: BatchDeleteResult = {
+    deleted: [],
+    failed: [],
+    methods: {
+      trash: 0,
+      unlink: 0,
+    },
+  };
+
+  for (const session of selectedSessions) {
+    if (currentSessionFile && session.path === currentSessionFile) {
+      result.failed.push({
+        session,
+        error: "Refused to delete the currently active session.",
+      });
+      continue;
+    }
+
+    try {
+      const deleteResult = await deleteSessionFile(session.path);
+      if (deleteResult.ok) {
+        result.deleted.push(session);
+        result.methods[deleteResult.method] += 1;
+      } else {
+        result.failed.push({
+          session,
+          error: deleteResult.error,
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.failed.push({
+        session,
+        error: message,
+      });
+    }
+  }
+
+  return result;
+}
+
+function notifyDeleteOutcome(ctx: ExtensionCommandContext, result: BatchDeleteResult): void {
+  const deletedCount = result.deleted.length;
+  const failedCount = result.failed.length;
+
+  if (deletedCount === 0 && failedCount > 0) {
+    ctx.ui.notify(
+      `No sessions were deleted.\n${summarizeFailures(result.failed)}`,
+      "error",
+    );
+    return;
+  }
+
+  if (failedCount === 0) {
+    ctx.ui.notify(
+      `Deleted ${deletedCount} session(s) (trash: ${result.methods.trash}, permanent: ${result.methods.unlink}).`,
+      "info",
+    );
+    return;
+  }
+
+  ctx.ui.notify(
+    `Deleted ${deletedCount} session(s), but ${failedCount} failed.\n${summarizeFailures(result.failed)}`,
+    "warning",
+  );
+}
+
+export function getSessionCleanupArgumentCompletions(
+  argumentPrefix: string,
+): Array<{ value: string; label: string; description?: string }> | null {
+  const normalizedPrefix = argumentPrefix.trim().toLowerCase();
+  if (!normalizedPrefix) {
+    return [...ARG_COMPLETIONS];
+  }
+
+  const matched = ARG_COMPLETIONS.filter((item) =>
+    item.value.startsWith(normalizedPrefix),
+  );
+  if (matched.length === 0) {
+    return null;
+  }
+
+  return matched.map((item) => ({ ...item }));
+}
+
+export async function handleSessionCleanupCommand(
+  args: string,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
+  const parsed = parseArgs(args);
+  if (parsed.help) {
+    ctx.ui.notify(usage(), "info");
+    return;
+  }
+
+  if (parsed.error) {
+    ctx.ui.notify(`${parsed.error}\n${usage()}`, "warning");
+    return;
+  }
+
+  if (!ctx.hasUI) {
+    ctx.ui.notify(`/${SESSION_CLEANUP_COMMAND} requires interactive TUI mode.`, "warning");
+    return;
+  }
+
+  const currentSessionFile = ctx.sessionManager.getSessionFile();
+
+  while (true) {
+    let sessions: SessionCleanupSession[];
+    try {
+      sessions = await loadSessions(ctx, parsed.scope);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`Failed to load sessions: ${message}`, "error");
+      return;
+    }
+
+    const candidates = sessions.filter(
+      (session) => session.path !== currentSessionFile,
+    );
+
+    if (candidates.length === 0) {
+      ctx.ui.notify(
+        "No deletable sessions found for this scope (current active session is excluded).",
+        "info",
+      );
+      return;
+    }
+
+    const selection = await selectSessionsForCleanup(ctx, candidates);
+    if (selection.cancelled) {
+      ctx.ui.notify("Session cleanup cancelled.", "info");
+      return;
+    }
+
+    if (selection.refreshRequested) {
+      continue;
+    }
+
+    const selectedSessions = candidates.filter((session) =>
+      selection.selectedPaths.has(session.path),
+    );
+
+    if (selectedSessions.length === 0) {
+      ctx.ui.notify("No sessions selected. Select one or more sessions first.", "warning");
+      continue;
+    }
+
+    const confirmed = await ctx.ui.confirm(
+      "Delete selected sessions",
+      buildConfirmationMessage(selectedSessions),
+    );
+
+    if (!confirmed) {
+      ctx.ui.notify("Delete cancelled.", "info");
+      return;
+    }
+
+    const deleteResult = await deleteSelectedSessions(
+      selectedSessions,
+      currentSessionFile,
+    );
+    notifyDeleteOutcome(ctx, deleteResult);
+    return;
+  }
+}

package/src/session-delete.ts

@@ -0,0 +1,50 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+
+import type { DeleteSessionResult } from "./types.js";
+
+function buildTrashErrorHint(result: ReturnType<typeof spawnSync>): string | null {
+  const details: string[] = [];
+
+  if (result.error) {
+    details.push(result.error.message);
+  }
+
+  const stderr = result.stderr?.toString().trim();
+  if (stderr) {
+    details.push(stderr.split("\n")[0] ?? stderr);
+  }
+
+  if (details.length === 0) {
+    return null;
+  }
+
+  return `trash: ${details.join(" · ").slice(0, 200)}`;
+}
+
+/**
+ * Mirrors Pi's built-in behavior: try moving to trash first, then fallback to unlink.
+ */
+export async function deleteSessionFile(sessionPath: string): Promise<DeleteSessionResult> {
+  const trashArgs = sessionPath.startsWith("-") ? ["--", sessionPath] : [sessionPath];
+  const trashResult = spawnSync("trash", trashArgs, { encoding: "utf-8" });
+
+  if (trashResult.status === 0 || !existsSync(sessionPath)) {
+    return { ok: true, method: "trash" };
+  }
+
+  try {
+    await unlink(sessionPath);
+    return { ok: true, method: "unlink" };
+  } catch (error) {
+    const unlinkError = error instanceof Error ? error.message : String(error);
+    const trashHint = buildTrashErrorHint(trashResult);
+
+    return {
+      ok: false,
+      method: "unlink",
+      error: trashHint ? `${unlinkError} (${trashHint})` : unlinkError,
+    };
+  }
+}

package/src/session-format.ts

@@ -0,0 +1,98 @@
+import { homedir } from "node:os";
+
+import type { SessionInfo } from "@mariozechner/pi-coding-agent";
+
+const LABEL_MAX_TEXT = 56;
+
+type SessionDisplayInfo = SessionInfo & {
+  responsibleAgentName?: string | null;
+};
+
+function compactWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function clipText(value: string, max = LABEL_MAX_TEXT): string {
+  if (value.length <= max) {
+    return value;
+  }
+
+  return `${value.slice(0, Math.max(1, max - 1))}…`;
+}
+
+export function shortenPath(path: string): string {
+  const home = homedir();
+  if (path.startsWith(home)) {
+    return `~${path.slice(home.length)}`;
+  }
+
+  return path;
+}
+
+export function formatSessionAge(date: Date, now = Date.now()): string {
+  const ageMs = Math.max(0, now - date.getTime());
+  const minutes = Math.floor(ageMs / 60000);
+
+  if (minutes < 1) {
+    return "now";
+  }
+
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h`;
+  }
+
+  const days = Math.floor(hours / 24);
+  if (days < 7) {
+    return `${days}d`;
+  }
+
+  if (days < 30) {
+    return `${Math.floor(days / 7)}w`;
+  }
+
+  if (days < 365) {
+    return `${Math.floor(days / 30)}mo`;
+  }
+
+  return `${Math.floor(days / 365)}y`;
+}
+
+export function getSessionTitle(session: SessionInfo): string {
+  const preferred = compactWhitespace(session.name ?? "");
+  if (preferred) {
+    return clipText(preferred);
+  }
+
+  const preview = compactWhitespace(session.firstMessage ?? "");
+  if (preview) {
+    return clipText(preview);
+  }
+
+  return "(no preview)";
+}
+
+export function getResponsibleAgentDisplayName(session: SessionDisplayInfo): string {
+  const normalizedAgentName = compactWhitespace(session.responsibleAgentName ?? "");
+  return normalizedAgentName || "unknown";
+}
+
+export function buildSessionSelectionLabel(
+  session: SessionDisplayInfo,
+  index: number,
+  selected: boolean,
+): string {
+  const marker = selected ? "[x]" : "[ ]";
+  const title = getSessionTitle(session);
+  const agent = `@${getResponsibleAgentDisplayName(session)}`;
+  const age = formatSessionAge(session.modified);
+  const shortId = session.id.slice(0, 8);
+  const cwd = shortenPath(session.cwd || "(unknown cwd)");
+  const position = String(index + 1).padStart(3, "0");
+
+  return `${position} ${marker} ${title} · ${agent} · ${age} · ${shortId} · ${cwd}`;
+}

package/src/session-nix-command.ts

@@ -0,0 +1,84 @@
+import { basename } from "node:path";
+
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import { SESSION_NIX_COMMAND } from "./constants.js";
+import { deleteSessionFile } from "./session-delete.js";
+
+function usage(): string {
+  return `Usage: /${SESSION_NIX_COMMAND}`;
+}
+
+function getSessionLabel(sessionPath: string): string {
+  const fileName = basename(sessionPath).trim();
+  return fileName.length > 0 ? fileName : sessionPath;
+}
+
+function buildConfirmationMessage(previousSessionFile: string | undefined): string {
+  if (!previousSessionFile) {
+    return "This will start a new session. The current session is not persisted yet, so there is no session file to delete.";
+  }
+
+  return [
+    "This will start a new session and permanently remove the current session from your session history.",
+    "",
+    `Current session: ${getSessionLabel(previousSessionFile)}`,
+    "",
+    "Pi will try moving it to trash first, then permanently delete it if trash is unavailable.",
+  ].join("\n");
+}
+
+export async function handleSessionNixCommand(
+  args: string,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
+  const normalizedArgs = args.trim();
+  if (normalizedArgs.toLowerCase() === "help") {
+    ctx.ui.notify(usage(), "info");
+    return;
+  }
+
+  if (normalizedArgs.length > 0) {
+    ctx.ui.notify(`/${SESSION_NIX_COMMAND} does not accept arguments.\n${usage()}`, "warning");
+    return;
+  }
+
+  if (!ctx.hasUI) {
+    ctx.ui.notify(`/${SESSION_NIX_COMMAND} requires interactive TUI mode.`, "warning");
+    return;
+  }
+
+  const previousSessionFile = ctx.sessionManager.getSessionFile();
+  const confirmed = await ctx.ui.confirm(
+    "Start fresh and delete current session",
+    buildConfirmationMessage(previousSessionFile),
+  );
+
+  if (!confirmed) {
+    ctx.ui.notify(`/${SESSION_NIX_COMMAND} cancelled.`, "info");
+    return;
+  }
+
+  try {
+    const newSessionResult = await ctx.newSession();
+    if (newSessionResult.cancelled) {
+      ctx.ui.notify("New session cancelled.", "info");
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Failed to start a new session: ${message}`, "error");
+    return;
+  }
+
+  // After successful ctx.newSession(), ctx is stale. Do NOT call ctx.ui.notify() below.
+  if (!previousSessionFile) {
+    return;
+  }
+
+  try {
+    await deleteSessionFile(previousSessionFile);
+  } catch {
+    // Deletion failure is non-critical; the session was already replaced.
+  }
+}

package/src/session-selection.ts

@@ -0,0 +1,167 @@
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+import { buildSessionSelectionLabel } from "./session-format.js";
+import { showSessionCleanupPicker } from "./tui/session-cleanup-picker.js";
+import type { SessionCleanupSession, SessionSelectionResult } from "./types.js";
+
+interface ConfirmAction {
+  kind: "confirm";
+}
+
+interface ToggleAllAction {
+  kind: "toggle-all";
+}
+
+interface RefreshAction {
+  kind: "refresh";
+}
+
+interface CancelAction {
+  kind: "cancel";
+}
+
+interface ToggleSessionAction {
+  kind: "toggle-session";
+  sessionPath: string;
+}
+
+type SelectionAction =
+  | ConfirmAction
+  | ToggleAllAction
+  | RefreshAction
+  | CancelAction
+  | ToggleSessionAction;
+
+function buildMenu(
+  sessions: readonly SessionCleanupSession[],
+  selectedPaths: ReadonlySet<string>,
+): {
+  labels: string[];
+  actionsByLabel: Map<string, SelectionAction>;
+} {
+  const labels: string[] = [];
+  const actionsByLabel = new Map<string, SelectionAction>();
+
+  const confirmLabel = `✅ Delete selected (${selectedPaths.size})`;
+  labels.push(confirmLabel);
+  actionsByLabel.set(confirmLabel, { kind: "confirm" });
+
+  const toggleAllLabel =
+    selectedPaths.size === sessions.length
+      ? "☐ Clear all selections"
+      : "☑ Select all sessions";
+  labels.push(toggleAllLabel);
+  actionsByLabel.set(toggleAllLabel, { kind: "toggle-all" });
+
+  const refreshLabel = "↻ Refresh session list";
+  labels.push(refreshLabel);
+  actionsByLabel.set(refreshLabel, { kind: "refresh" });
+
+  const cancelLabel = "✖ Cancel";
+  labels.push(cancelLabel);
+  actionsByLabel.set(cancelLabel, { kind: "cancel" });
+
+  sessions.forEach((session, index) => {
+    const label = buildSessionSelectionLabel(
+      session,
+      index,
+      selectedPaths.has(session.path),
+    );
+    labels.push(label);
+    actionsByLabel.set(label, {
+      kind: "toggle-session",
+      sessionPath: session.path,
+    });
+  });
+
+  return { labels, actionsByLabel };
+}
+
+async function selectSessionsWithLegacyMenu(
+  ctx: ExtensionCommandContext,
+  sessions: readonly SessionCleanupSession[],
+): Promise<SessionSelectionResult> {
+  const selectedPaths = new Set<string>();
+
+  while (true) {
+    const menu = buildMenu(sessions, selectedPaths);
+    const selectedLabel = await ctx.ui.select(
+      "Select sessions to delete (toggle multiple, then confirm)",
+      menu.labels,
+    );
+
+    if (!selectedLabel) {
+      return {
+        cancelled: true,
+        refreshRequested: false,
+        selectedPaths,
+      };
+    }
+
+    const action = menu.actionsByLabel.get(selectedLabel);
+    if (!action) {
+      ctx.ui.notify("Unknown selection action. Please try again.", "warning");
+      continue;
+    }
+
+    switch (action.kind) {
+      case "confirm": {
+        return {
+          cancelled: false,
+          refreshRequested: false,
+          selectedPaths,
+        };
+      }
+      case "toggle-all": {
+        if (selectedPaths.size === sessions.length) {
+          selectedPaths.clear();
+        } else {
+          sessions.forEach((session) => selectedPaths.add(session.path));
+        }
+        break;
+      }
+      case "refresh": {
+        return {
+          cancelled: false,
+          refreshRequested: true,
+          selectedPaths,
+        };
+      }
+      case "cancel": {
+        return {
+          cancelled: true,
+          refreshRequested: false,
+          selectedPaths,
+        };
+      }
+      case "toggle-session": {
+        if (selectedPaths.has(action.sessionPath)) {
+          selectedPaths.delete(action.sessionPath);
+        } else {
+          selectedPaths.add(action.sessionPath);
+        }
+        break;
+      }
+      default: {
+        const unreachable: never = action;
+        throw new Error(`Unhandled selection action: ${String(unreachable)}`);
+      }
+    }
+  }
+}
+
+export async function selectSessionsForCleanup(
+  ctx: ExtensionCommandContext,
+  sessions: readonly SessionCleanupSession[],
+): Promise<SessionSelectionResult> {
+  try {
+    return await showSessionCleanupPicker(ctx, sessions);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(
+      `Interactive picker failed (${message}). Falling back to basic selector.`,
+      "warning",
+    );
+    return selectSessionsWithLegacyMenu(ctx, sessions);
+  }
+}