@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-HRS4HMDX.js

@@ -0,0 +1,610 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  KeybindingsManager
+} from "./chunk-CH6OL6P2.js";
+import {
+  DynamicBorder
+} from "./chunk-3GHXVUAK.js";
+import {
+  keyHint,
+  keyText
+} from "./chunk-C4O2RSQQ.js";
+import {
+  theme
+} from "./chunk-MX3GJNXJ.js";
+import {
+  canonicalizePath
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/modes/interactive/components/session-selector.js
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import * as os from "node:os";
+import { Container, getKeybindings, Input, Spacer, Text, truncateToWidth, visibleWidth } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/modes/interactive/components/session-selector-search.js
+import { fuzzyMatch } from "@ashx-j/lunr-tui";
+function normalizeWhitespaceLower(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function getSessionSearchText(session) {
+  return `${session.id} ${session.name ?? ""} ${session.allMessagesText} ${session.cwd}`;
+}
+function hasSessionName(session) {
+  return !!session.name?.trim();
+}
+function matchesNameFilter(session, filter) {
+  return filter === "all" ? !0 : hasSessionName(session);
+}
+function parseSearchQuery(query) {
+  let trimmed = query.trim();
+  if (!trimmed)
+    return { mode: "tokens", tokens: [], regex: null };
+  if (trimmed.startsWith("re:")) {
+    let pattern = trimmed.slice(3).trim();
+    if (!pattern)
+      return { mode: "regex", tokens: [], regex: null, error: "Empty regex" };
+    try {
+      return { mode: "regex", tokens: [], regex: new RegExp(pattern, "i") };
+    } catch (err) {
+      let msg = err instanceof Error ? err.message : String(err);
+      return { mode: "regex", tokens: [], regex: null, error: msg };
+    }
+  }
+  let tokens = [], buf = "", inQuote = !1, hadUnclosedQuote = !1, flush = (kind) => {
+    let v = buf.trim();
+    buf = "", v && tokens.push({ kind, value: v });
+  };
+  for (let i = 0; i < trimmed.length; i++) {
+    let ch = trimmed[i];
+    if (ch === '"') {
+      inQuote ? (flush("phrase"), inQuote = !1) : (flush("fuzzy"), inQuote = !0);
+      continue;
+    }
+    if (!inQuote && /\s/.test(ch)) {
+      flush("fuzzy");
+      continue;
+    }
+    buf += ch;
+  }
+  return inQuote && (hadUnclosedQuote = !0), hadUnclosedQuote ? {
+    mode: "tokens",
+    tokens: trimmed.split(/\s+/).map((t) => t.trim()).filter((t) => t.length > 0).map((t) => ({ kind: "fuzzy", value: t })),
+    regex: null
+  } : (flush(inQuote ? "phrase" : "fuzzy"), { mode: "tokens", tokens, regex: null });
+}
+function matchSession(session, parsed) {
+  let text = getSessionSearchText(session);
+  if (parsed.mode === "regex") {
+    if (!parsed.regex)
+      return { matches: !1, score: 0 };
+    let idx = text.search(parsed.regex);
+    return idx < 0 ? { matches: !1, score: 0 } : { matches: !0, score: idx * 0.1 };
+  }
+  if (parsed.tokens.length === 0)
+    return { matches: !0, score: 0 };
+  let totalScore = 0, normalizedText = null;
+  for (let token of parsed.tokens) {
+    if (token.kind === "phrase") {
+      normalizedText === null && (normalizedText = normalizeWhitespaceLower(text));
+      let phrase = normalizeWhitespaceLower(token.value);
+      if (!phrase)
+        continue;
+      let idx = normalizedText.indexOf(phrase);
+      if (idx < 0)
+        return { matches: !1, score: 0 };
+      totalScore += idx * 0.1;
+      continue;
+    }
+    let m = fuzzyMatch(token.value, text);
+    if (!m.matches)
+      return { matches: !1, score: 0 };
+    totalScore += m.score;
+  }
+  return { matches: !0, score: totalScore };
+}
+function filterAndSortSessions(sessions, query, sortMode, nameFilter = "all") {
+  let nameFiltered = nameFilter === "all" ? sessions : sessions.filter((session) => matchesNameFilter(session, nameFilter));
+  if (!query.trim())
+    return nameFiltered;
+  let parsed = parseSearchQuery(query);
+  if (parsed.error)
+    return [];
+  if (sortMode === "recent") {
+    let filtered = [];
+    for (let s of nameFiltered)
+      matchSession(s, parsed).matches && filtered.push(s);
+    return filtered;
+  }
+  let scored = [];
+  for (let s of nameFiltered) {
+    let res = matchSession(s, parsed);
+    res.matches && scored.push({ session: s, score: res.score });
+  }
+  return scored.sort((a, b) => a.score !== b.score ? a.score - b.score : b.session.modified.getTime() - a.session.modified.getTime()), scored.map((r) => r.session);
+}
+
+// packages/coding-agent/dist/modes/interactive/components/session-selector.js
+function shortenPath(path) {
+  let home = os.homedir();
+  return path && (path.startsWith(home) ? `~${path.slice(home.length)}` : path);
+}
+function formatSessionDate(date) {
+  let diffMs = (/* @__PURE__ */ new Date()).getTime() - date.getTime(), diffMins = Math.floor(diffMs / 6e4), diffHours = Math.floor(diffMs / 36e5), diffDays = Math.floor(diffMs / 864e5);
+  return diffMins < 1 ? "now" : diffMins < 60 ? `${diffMins}m` : diffHours < 24 ? `${diffHours}h` : diffDays < 7 ? `${diffDays}d` : diffDays < 30 ? `${Math.floor(diffDays / 7)}w` : diffDays < 365 ? `${Math.floor(diffDays / 30)}mo` : `${Math.floor(diffDays / 365)}y`;
+}
+function canonicalizePath2(path) {
+  return path && canonicalizePath(path);
+}
+var SessionSelectorHeader = class {
+  scope;
+  sortMode;
+  nameFilter;
+  requestRender;
+  loading = !1;
+  loadProgress = null;
+  showPath = !1;
+  confirmingDeletePath = null;
+  statusMessage = null;
+  statusTimeout = null;
+  showRenameHint = !1;
+  constructor(scope, sortMode, nameFilter, requestRender) {
+    this.scope = scope, this.sortMode = sortMode, this.nameFilter = nameFilter, this.requestRender = requestRender;
+  }
+  setScope(scope) {
+    this.scope = scope;
+  }
+  setSortMode(sortMode) {
+    this.sortMode = sortMode;
+  }
+  setNameFilter(nameFilter) {
+    this.nameFilter = nameFilter;
+  }
+  setLoading(loading) {
+    this.loading = loading, this.loadProgress = null;
+  }
+  setProgress(loaded, total) {
+    this.loadProgress = { loaded, total };
+  }
+  setShowPath(showPath) {
+    this.showPath = showPath;
+  }
+  setShowRenameHint(show) {
+    this.showRenameHint = show;
+  }
+  setConfirmingDeletePath(path) {
+    this.confirmingDeletePath = path;
+  }
+  clearStatusTimeout() {
+    this.statusTimeout && (clearTimeout(this.statusTimeout), this.statusTimeout = null);
+  }
+  setStatusMessage(msg, autoHideMs) {
+    this.clearStatusTimeout(), this.statusMessage = msg, !(!msg || !autoHideMs) && (this.statusTimeout = setTimeout(() => {
+      this.statusMessage = null, this.statusTimeout = null, this.requestRender();
+    }, autoHideMs));
+  }
+  invalidate() {
+  }
+  render(width) {
+    let title = this.scope === "current" ? "Resume Session (Current Folder)" : "Resume Session (All)", leftText = theme.bold(title), sortLabel = this.sortMode === "threaded" ? "Threaded" : this.sortMode === "recent" ? "Recent" : "Fuzzy", sortText = theme.fg("muted", "Sort: ") + theme.fg("accent", sortLabel), nameLabel = this.nameFilter === "all" ? "All" : "Named", nameText = theme.fg("muted", "Name: ") + theme.fg("accent", nameLabel), scopeText;
+    if (this.loading) {
+      let progressText = this.loadProgress ? `${this.loadProgress.loaded}/${this.loadProgress.total}` : "...";
+      scopeText = `${theme.fg("muted", "\u25CB Current Folder | ")}${theme.fg("accent", `Loading ${progressText}`)}`;
+    } else this.scope === "current" ? scopeText = `${theme.fg("accent", "\u25C9 Current Folder")}${theme.fg("muted", " | \u25CB All")}` : scopeText = `${theme.fg("muted", "\u25CB Current Folder | ")}${theme.fg("accent", "\u25C9 All")}`;
+    let rightText = truncateToWidth(`${scopeText}  ${nameText}  ${sortText}`, width, ""), availableLeft = Math.max(0, width - visibleWidth(rightText) - 1), left = truncateToWidth(leftText, availableLeft, ""), spacing = Math.max(0, width - visibleWidth(left) - visibleWidth(rightText)), hintLine1, hintLine2;
+    if (this.confirmingDeletePath !== null) {
+      let confirmHint = `Delete session? ${keyHint("tui.select.confirm", "confirm")} \xB7 ${keyHint("tui.select.cancel", "cancel")}`;
+      hintLine1 = theme.fg("error", truncateToWidth(confirmHint, width, "\u2026")), hintLine2 = "";
+    } else if (this.statusMessage) {
+      let color = this.statusMessage.type === "error" ? "error" : "accent";
+      hintLine1 = theme.fg(color, truncateToWidth(this.statusMessage.message, width, "\u2026")), hintLine2 = "";
+    } else {
+      let pathState = this.showPath ? "(on)" : "(off)", sep = theme.fg("muted", " \xB7 "), hint1 = keyHint("tui.input.tab", "scope") + sep + theme.fg("muted", 're:<pattern> regex \xB7 "phrase" exact'), hint2Parts = [
+        keyHint("app.session.toggleSort", "sort"),
+        keyHint("app.session.toggleNamedFilter", "named"),
+        keyHint("app.session.delete", "delete"),
+        keyHint("app.session.togglePath", `path ${pathState}`)
+      ];
+      this.showRenameHint && hint2Parts.push(keyHint("app.session.rename", "rename"));
+      let hint2 = hint2Parts.join(sep);
+      hintLine1 = truncateToWidth(hint1, width, "\u2026"), hintLine2 = truncateToWidth(hint2, width, "\u2026");
+    }
+    return [`${left}${" ".repeat(spacing)}${rightText}`, hintLine1, hintLine2];
+  }
+};
+function buildSessionTree(sessions) {
+  let byPath = /* @__PURE__ */ new Map();
+  for (let session of sessions) {
+    let sessionPath = canonicalizePath2(session.path) ?? session.path;
+    byPath.set(sessionPath, { session, children: [], latestActivity: session.modified.getTime() });
+  }
+  let roots = [];
+  for (let session of sessions) {
+    let sessionPath = canonicalizePath2(session.path) ?? session.path, node = byPath.get(sessionPath), parentPath = canonicalizePath2(session.parentSessionPath);
+    parentPath && byPath.has(parentPath) ? byPath.get(parentPath).children.push(node) : roots.push(node);
+  }
+  let updateLatestActivity = (node) => {
+    let latestActivity = node.session.modified.getTime();
+    for (let child of node.children)
+      latestActivity = Math.max(latestActivity, updateLatestActivity(child));
+    return node.latestActivity = latestActivity, latestActivity;
+  };
+  for (let root of roots)
+    updateLatestActivity(root);
+  let sortNodes = (nodes) => {
+    nodes.sort((a, b) => b.latestActivity - a.latestActivity);
+    for (let node of nodes)
+      sortNodes(node.children);
+  };
+  return sortNodes(roots), roots;
+}
+function flattenSessionTree(roots) {
+  let result = [], walk = (node, depth, ancestorContinues, isLast) => {
+    result.push({ session: node.session, depth, isLast, ancestorContinues });
+    for (let i = 0; i < node.children.length; i++) {
+      let childIsLast = i === node.children.length - 1, continues = depth > 0 ? !isLast : !1;
+      walk(node.children[i], depth + 1, [...ancestorContinues, continues], childIsLast);
+    }
+  };
+  for (let i = 0; i < roots.length; i++)
+    walk(roots[i], 0, [], i === roots.length - 1);
+  return result;
+}
+var SessionList = class {
+  getSelectedSessionPath() {
+    return this.filteredSessions[this.selectedIndex]?.session.path;
+  }
+  allSessions = [];
+  filteredSessions = [];
+  selectedIndex = 0;
+  searchInput;
+  showCwd = !1;
+  sortMode = "threaded";
+  nameFilter = "all";
+  keybindings;
+  showPath = !1;
+  confirmingDeletePath = null;
+  currentSessionCanonicalPath;
+  onSelect;
+  onCancel;
+  onExit = () => {
+  };
+  onToggleScope;
+  onToggleSort;
+  onToggleNameFilter;
+  onTogglePath;
+  onDeleteConfirmationChange;
+  onDeleteSession;
+  onRenameSession;
+  onError;
+  maxVisible = 10;
+  // Max sessions visible (one line each)
+  // Focusable implementation - propagate to searchInput for IME cursor positioning
+  _focused = !1;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value, this.searchInput.focused = value;
+  }
+  constructor(sessions, showCwd, sortMode, nameFilter, keybindings, currentSessionFilePath) {
+    this.allSessions = sessions, this.filteredSessions = [], this.searchInput = new Input(), this.showCwd = showCwd, this.sortMode = sortMode, this.nameFilter = nameFilter, this.keybindings = keybindings, this.currentSessionCanonicalPath = canonicalizePath2(currentSessionFilePath), this.filterSessions(""), this.searchInput.onSubmit = () => {
+      if (this.filteredSessions[this.selectedIndex]) {
+        let selected = this.filteredSessions[this.selectedIndex];
+        this.onSelect && this.onSelect(selected.session.path);
+      }
+    };
+  }
+  setSortMode(sortMode) {
+    this.sortMode = sortMode, this.filterSessions(this.searchInput.getValue());
+  }
+  setNameFilter(nameFilter) {
+    this.nameFilter = nameFilter, this.filterSessions(this.searchInput.getValue());
+  }
+  setSessions(sessions, showCwd) {
+    this.allSessions = sessions, this.showCwd = showCwd, this.filterSessions(this.searchInput.getValue());
+  }
+  filterSessions(query) {
+    let trimmed = query.trim(), nameFiltered = this.nameFilter === "all" ? this.allSessions : this.allSessions.filter((session) => hasSessionName(session));
+    if (this.sortMode === "threaded" && !trimmed) {
+      let roots = buildSessionTree(nameFiltered);
+      this.filteredSessions = flattenSessionTree(roots);
+    } else {
+      let filtered = filterAndSortSessions(nameFiltered, query, this.sortMode, "all");
+      this.filteredSessions = filtered.map((session) => ({
+        session,
+        depth: 0,
+        isLast: !0,
+        ancestorContinues: []
+      }));
+    }
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredSessions.length - 1));
+  }
+  setConfirmingDeletePath(path) {
+    this.confirmingDeletePath = path, this.onDeleteConfirmationChange?.(path);
+  }
+  startDeleteConfirmationForSelectedSession() {
+    let selected = this.filteredSessions[this.selectedIndex];
+    if (selected) {
+      if (this.isCurrentSessionPath(selected.session.path)) {
+        this.onError?.("Cannot delete the currently active session");
+        return;
+      }
+      this.setConfirmingDeletePath(selected.session.path);
+    }
+  }
+  isCurrentSessionPath(path) {
+    return this.currentSessionCanonicalPath ? (canonicalizePath2(path) ?? path) === this.currentSessionCanonicalPath : !1;
+  }
+  invalidate() {
+  }
+  render(width) {
+    let lines = [];
+    if (lines.push(...this.searchInput.render(width)), lines.push(""), this.filteredSessions.length === 0) {
+      let emptyMessage;
+      if (this.nameFilter === "named") {
+        let toggleKey = keyText("app.session.toggleNamedFilter");
+        this.showCwd ? emptyMessage = `  No named sessions found. Press ${toggleKey} to show all.` : emptyMessage = `  No named sessions in current folder. Press ${toggleKey} to show all, or Tab to view all.`;
+      } else this.showCwd ? emptyMessage = "  No sessions found" : emptyMessage = "  No sessions in current folder. Press Tab to view all.";
+      return lines.push(theme.fg("muted", truncateToWidth(emptyMessage, width, "\u2026"))), lines;
+    }
+    let startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredSessions.length - this.maxVisible)), endIndex = Math.min(startIndex + this.maxVisible, this.filteredSessions.length);
+    for (let i = startIndex; i < endIndex; i++) {
+      let node = this.filteredSessions[i], session = node.session, isSelected = i === this.selectedIndex, isConfirmingDelete = session.path === this.confirmingDeletePath, isCurrent = this.isCurrentSessionPath(session.path), prefix = this.buildTreePrefix(node), normalizedMessage = (session.name ?? session.firstMessage).replace(/[\x00-\x1f\x7f]/g, " ").trim(), age = formatSessionDate(session.modified), rightPart = `${String(session.messageCount)} ${age}`;
+      this.showCwd && session.cwd && (rightPart = `${shortenPath(session.cwd)} ${rightPart}`), this.showPath && (rightPart = `${shortenPath(session.path)} ${rightPart}`);
+      let cursor = isSelected ? theme.fg("accent", "\u203A ") : "  ", prefixWidth = visibleWidth(prefix), rightWidth = visibleWidth(rightPart) + 2, availableForMsg = width - 2 - prefixWidth - rightWidth, truncatedMsg = truncateToWidth(normalizedMessage, Math.max(10, availableForMsg), "\u2026"), messageColor = null;
+      isConfirmingDelete ? messageColor = "error" : (isSelected || isCurrent) && (messageColor = "accent");
+      let styledMsg = messageColor ? theme.fg(messageColor, truncatedMsg) : truncatedMsg, leftPart = cursor + theme.fg("dim", prefix) + styledMsg, leftWidth = visibleWidth(leftPart), spacing = Math.max(1, width - leftWidth - visibleWidth(rightPart)), styledRight = theme.fg(isConfirmingDelete ? "error" : "dim", rightPart), line = leftPart + " ".repeat(spacing) + styledRight;
+      lines.push(truncateToWidth(line, width));
+    }
+    if (startIndex > 0 || endIndex < this.filteredSessions.length) {
+      let scrollText = `  (${this.selectedIndex + 1}/${this.filteredSessions.length})`, scrollInfo = theme.fg("muted", truncateToWidth(scrollText, width, ""));
+      lines.push(scrollInfo);
+    }
+    return lines;
+  }
+  buildTreePrefix(node) {
+    if (node.depth === 0)
+      return "";
+    let parts = node.ancestorContinues.map((continues) => continues ? "\u2502  " : "   "), branch = node.isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
+    return parts.join("") + branch;
+  }
+  handleInput(keyData) {
+    let kb = getKeybindings();
+    if (this.confirmingDeletePath !== null) {
+      if (kb.matches(keyData, "tui.select.confirm")) {
+        let pathToDelete = this.confirmingDeletePath;
+        this.setConfirmingDeletePath(null), this.onDeleteSession?.(pathToDelete);
+        return;
+      }
+      if (kb.matches(keyData, "tui.select.cancel")) {
+        this.setConfirmingDeletePath(null);
+        return;
+      }
+      return;
+    }
+    if (kb.matches(keyData, "tui.input.tab")) {
+      this.onToggleScope && this.onToggleScope();
+      return;
+    }
+    if (kb.matches(keyData, "app.session.toggleSort")) {
+      this.onToggleSort?.();
+      return;
+    }
+    if (this.keybindings.matches(keyData, "app.session.toggleNamedFilter")) {
+      this.onToggleNameFilter?.();
+      return;
+    }
+    if (kb.matches(keyData, "app.session.togglePath")) {
+      this.showPath = !this.showPath, this.onTogglePath?.(this.showPath);
+      return;
+    }
+    if (kb.matches(keyData, "app.session.delete")) {
+      this.startDeleteConfirmationForSelectedSession();
+      return;
+    }
+    if (kb.matches(keyData, "app.session.rename")) {
+      let selected = this.filteredSessions[this.selectedIndex];
+      selected && this.onRenameSession?.(selected.session.path);
+      return;
+    }
+    if (kb.matches(keyData, "app.session.deleteNoninvasive")) {
+      if (this.searchInput.getValue().length > 0) {
+        this.searchInput.handleInput(keyData), this.filterSessions(this.searchInput.getValue());
+        return;
+      }
+      this.startDeleteConfirmationForSelectedSession();
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.up"))
+      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+    else if (kb.matches(keyData, "tui.select.down"))
+      this.selectedIndex = Math.min(this.filteredSessions.length - 1, this.selectedIndex + 1);
+    else if (kb.matches(keyData, "tui.select.pageUp"))
+      this.selectedIndex = Math.max(0, this.selectedIndex - this.maxVisible);
+    else if (kb.matches(keyData, "tui.select.pageDown"))
+      this.selectedIndex = Math.min(this.filteredSessions.length - 1, this.selectedIndex + this.maxVisible);
+    else if (kb.matches(keyData, "tui.select.confirm")) {
+      let selected = this.filteredSessions[this.selectedIndex];
+      selected && this.onSelect && this.onSelect(selected.session.path);
+    } else kb.matches(keyData, "tui.select.cancel") ? this.onCancel && this.onCancel() : (this.searchInput.handleInput(keyData), this.filterSessions(this.searchInput.getValue()));
+  }
+};
+async function deleteSessionFile(sessionPath) {
+  let trashArgs = sessionPath.startsWith("-") ? ["--", sessionPath] : [sessionPath], trashResult = spawnSync("trash", trashArgs, { encoding: "utf-8" }), getTrashErrorHint = () => {
+    let parts = [];
+    trashResult.error && parts.push(trashResult.error.message);
+    let stderr = trashResult.stderr?.trim();
+    return stderr && parts.push(stderr.split(`
+`)[0] ?? stderr), parts.length === 0 ? null : `trash: ${parts.join(" \xB7 ").slice(0, 200)}`;
+  };
+  if (trashResult.status === 0 || !existsSync(sessionPath))
+    return { ok: !0, method: "trash" };
+  try {
+    return await unlink(sessionPath), { ok: !0, method: "unlink" };
+  } catch (err) {
+    let unlinkError = err instanceof Error ? err.message : String(err), trashErrorHint = getTrashErrorHint();
+    return { ok: !1, method: "unlink", error: trashErrorHint ? `${unlinkError} (${trashErrorHint})` : unlinkError };
+  }
+}
+var SessionSelectorComponent = class extends Container {
+  handleInput(data) {
+    if (this.mode === "rename") {
+      if (getKeybindings().matches(data, "tui.select.cancel")) {
+        this.exitRenameMode();
+        return;
+      }
+      this.renameInput.handleInput(data);
+      return;
+    }
+    this.sessionList.handleInput(data);
+  }
+  canRename = !0;
+  sessionList;
+  header;
+  keybindings;
+  scope = "current";
+  sortMode = "threaded";
+  nameFilter = "all";
+  currentSessions = null;
+  allSessions = null;
+  currentSessionsLoader;
+  allSessionsLoader;
+  requestRender;
+  renameSession;
+  currentLoading = !1;
+  allLoading = !1;
+  allLoadSeq = 0;
+  mode = "list";
+  renameInput = new Input();
+  renameTargetPath = null;
+  // Focusable implementation - propagate to sessionList for IME cursor positioning
+  _focused = !1;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value, this.sessionList.focused = value, this.renameInput.focused = value, value && this.mode === "rename" && (this.renameInput.focused = !0);
+  }
+  buildBaseLayout(content, options) {
+    this.clear(), this.addChild(new Spacer(1)), this.addChild(new DynamicBorder((s) => theme.fg("accent", s))), this.addChild(new Spacer(1)), (options?.showHeader ?? !0) && (this.addChild(this.header), this.addChild(new Spacer(1))), this.addChild(content), this.addChild(new Spacer(1)), this.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+  }
+  constructor(currentSessionsLoader, allSessionsLoader, onSelect, onCancel, onExit, requestRender, options, currentSessionFilePath) {
+    super(), this.keybindings = options?.keybindings ?? KeybindingsManager.create(), this.currentSessionsLoader = currentSessionsLoader, this.allSessionsLoader = allSessionsLoader, this.requestRender = requestRender, this.header = new SessionSelectorHeader(this.scope, this.sortMode, this.nameFilter, this.requestRender);
+    let renameSession = options?.renameSession;
+    this.renameSession = renameSession, this.canRename = !!renameSession, this.header.setShowRenameHint(options?.showRenameHint ?? this.canRename), this.sessionList = new SessionList([], !1, this.sortMode, this.nameFilter, this.keybindings, currentSessionFilePath), this.buildBaseLayout(this.sessionList), this.renameInput.onSubmit = (value) => {
+      this.confirmRename(value);
+    };
+    let clearStatusMessage = () => this.header.setStatusMessage(null);
+    this.sessionList.onSelect = (sessionPath) => {
+      clearStatusMessage(), onSelect(sessionPath);
+    }, this.sessionList.onCancel = () => {
+      clearStatusMessage(), onCancel();
+    }, this.sessionList.onExit = () => {
+      clearStatusMessage(), onExit();
+    }, this.sessionList.onToggleScope = () => this.toggleScope(), this.sessionList.onToggleSort = () => this.toggleSortMode(), this.sessionList.onToggleNameFilter = () => this.toggleNameFilter(), this.sessionList.onRenameSession = (sessionPath) => {
+      if (!renameSession || this.scope === "current" && this.currentLoading || this.scope === "all" && this.allLoading)
+        return;
+      let session = (this.scope === "all" ? this.allSessions ?? [] : this.currentSessions ?? []).find((s) => s.path === sessionPath);
+      this.enterRenameMode(sessionPath, session?.name);
+    }, this.sessionList.onTogglePath = (showPath) => {
+      this.header.setShowPath(showPath), this.requestRender();
+    }, this.sessionList.onDeleteConfirmationChange = (path) => {
+      this.header.setConfirmingDeletePath(path), this.requestRender();
+    }, this.sessionList.onError = (msg) => {
+      this.header.setStatusMessage({ type: "error", message: msg }, 3e3), this.requestRender();
+    }, this.sessionList.onDeleteSession = async (sessionPath) => {
+      let result = await deleteSessionFile(sessionPath);
+      if (result.ok) {
+        this.currentSessions && (this.currentSessions = this.currentSessions.filter((s) => s.path !== sessionPath)), this.allSessions && (this.allSessions = this.allSessions.filter((s) => s.path !== sessionPath));
+        let sessions = this.scope === "all" ? this.allSessions ?? [] : this.currentSessions ?? [], showCwd = this.scope === "all";
+        this.sessionList.setSessions(sessions, showCwd);
+        let msg = result.method === "trash" ? "Session moved to trash" : "Session deleted";
+        this.header.setStatusMessage({ type: "info", message: msg }, 2e3), await this.refreshSessionsAfterMutation();
+      } else {
+        let errorMessage = result.error ?? "Unknown error";
+        this.header.setStatusMessage({ type: "error", message: `Failed to delete: ${errorMessage}` }, 3e3);
+      }
+      this.requestRender();
+    }, this.loadCurrentSessions();
+  }
+  loadCurrentSessions() {
+    this.loadScope("current", "initial");
+  }
+  enterRenameMode(sessionPath, currentName) {
+    this.mode = "rename", this.renameTargetPath = sessionPath, this.renameInput.setValue(currentName ?? ""), this.renameInput.focused = !0;
+    let panel = new Container();
+    panel.addChild(new Text(theme.bold("Rename Session"), 1, 0)), panel.addChild(new Spacer(1)), panel.addChild(this.renameInput), panel.addChild(new Spacer(1)), panel.addChild(new Text(theme.fg("muted", `${keyText("tui.select.confirm")} to save \xB7 ${keyText("tui.select.cancel")} to cancel`), 1, 0)), this.buildBaseLayout(panel, { showHeader: !1 }), this.requestRender();
+  }
+  exitRenameMode() {
+    this.mode = "list", this.renameTargetPath = null, this.buildBaseLayout(this.sessionList), this.requestRender();
+  }
+  async confirmRename(value) {
+    let next = value.trim();
+    if (!next)
+      return;
+    let target = this.renameTargetPath;
+    if (!target) {
+      this.exitRenameMode();
+      return;
+    }
+    let renameSession = this.renameSession;
+    if (!renameSession) {
+      this.exitRenameMode();
+      return;
+    }
+    try {
+      await renameSession(target, next), await this.refreshSessionsAfterMutation();
+    } finally {
+      this.exitRenameMode();
+    }
+  }
+  async loadScope(scope, reason) {
+    let showCwd = scope === "all";
+    scope === "current" ? this.currentLoading = !0 : this.allLoading = !0;
+    let seq = scope === "all" ? ++this.allLoadSeq : void 0;
+    this.header.setScope(scope), this.header.setLoading(!0), this.requestRender();
+    let onProgress = (loaded, total) => {
+      scope === this.scope && (seq !== void 0 && seq !== this.allLoadSeq || (this.header.setProgress(loaded, total), this.requestRender()));
+    };
+    try {
+      let sessions = await (scope === "current" ? this.currentSessionsLoader(onProgress) : this.allSessionsLoader(onProgress));
+      if (scope === "current" ? (this.currentSessions = sessions, this.currentLoading = !1) : (this.allSessions = sessions, this.allLoading = !1), scope !== this.scope || seq !== void 0 && seq !== this.allLoadSeq)
+        return;
+      this.header.setLoading(!1), this.sessionList.setSessions(sessions, showCwd), this.requestRender();
+    } catch (err) {
+      if (scope === "current" ? this.currentLoading = !1 : this.allLoading = !1, scope !== this.scope || seq !== void 0 && seq !== this.allLoadSeq)
+        return;
+      let message = err instanceof Error ? err.message : String(err);
+      this.header.setLoading(!1), this.header.setStatusMessage({ type: "error", message: `Failed to load sessions: ${message}` }, 4e3), reason === "initial" && this.sessionList.setSessions([], showCwd), this.requestRender();
+    }
+  }
+  toggleSortMode() {
+    this.sortMode = this.sortMode === "threaded" ? "recent" : this.sortMode === "recent" ? "relevance" : "threaded", this.header.setSortMode(this.sortMode), this.sessionList.setSortMode(this.sortMode), this.requestRender();
+  }
+  toggleNameFilter() {
+    this.nameFilter = this.nameFilter === "all" ? "named" : "all", this.header.setNameFilter(this.nameFilter), this.sessionList.setNameFilter(this.nameFilter), this.requestRender();
+  }
+  async refreshSessionsAfterMutation() {
+    await this.loadScope(this.scope, "refresh");
+  }
+  toggleScope() {
+    if (this.scope === "current") {
+      if (this.scope = "all", this.header.setScope(this.scope), this.allSessions !== null) {
+        this.header.setLoading(!1), this.sessionList.setSessions(this.allSessions, !0), this.requestRender();
+        return;
+      }
+      this.allLoading || this.loadScope("all", "toggle");
+      return;
+    }
+    this.scope = "current", this.header.setScope(this.scope), this.header.setLoading(this.currentLoading), this.sessionList.setSessions(this.currentSessions ?? [], !1), this.requestRender();
+  }
+  getSessionList() {
+    return this.sessionList;
+  }
+};
+
+export {
+  SessionSelectorComponent
+};

package/dist/node-runtime/chunk-HYHJIRDW.js

@@ -0,0 +1,19 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/panel-keys.js
+import { matchesKey } from "@ashx-j/lunr-tui";
+function createPanelKeys(keybindings) {
+  return keybindings ? {
+    selectUp: (data) => keybindings.matches(data, "tui.select.up"),
+    selectDown: (data) => keybindings.matches(data, "tui.select.down"),
+    selectConfirm: (data) => keybindings.matches(data, "tui.select.confirm")
+  } : {
+    selectUp: (data) => matchesKey(data, "up"),
+    selectDown: (data) => matchesKey(data, "down"),
+    selectConfirm: (data) => matchesKey(data, "return")
+  };
+}
+
+export {
+  createPanelKeys
+};

package/dist/node-runtime/chunk-I6R76AG7.js

@@ -0,0 +1,22 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/modes/interactive/components/countdown-timer.js
+var CountdownTimer = class {
+  intervalId;
+  remainingSeconds;
+  tui;
+  onTick;
+  onExpire;
+  constructor(timeoutMs, tui, onTick, onExpire) {
+    this.tui = tui, this.onTick = onTick, this.onExpire = onExpire, this.remainingSeconds = Math.ceil(timeoutMs / 1e3), this.onTick(this.remainingSeconds), this.intervalId = setInterval(() => {
+      this.remainingSeconds--, this.onTick(this.remainingSeconds), this.tui?.requestRender(), this.remainingSeconds <= 0 && (this.dispose(), this.onExpire());
+    }, 1e3);
+  }
+  dispose() {
+    this.intervalId && (clearInterval(this.intervalId), this.intervalId = void 0);
+  }
+};
+
+export {
+  CountdownTimer
+};