theus-cli-linux-x64 1.2.1 → 1.3.0

package/vendor/theus-arsenal/scripts/lib/session-manager.d.ts

@@ -1,137 +0,0 @@
-/**
- * Biblioteca de gestión de sesiones para Theus.
- * Provee operaciones CRUD para archivos de sesión guardados como markdown en
- * `<data home>/session-data/` (por defecto ~/.theus/arsenal/session-data/) con
- * compatibilidad de lectura para el directorio heredado `<data home>/sessions/`.
- */
-
-/** Metadatos parseados del nombre de archivo de una sesión */
-export interface SessionFilenameMeta {
-  /** Nombre de archivo original */
-  filename: string;
-  /** ID corto extraído del nombre de archivo, o "no-id" para el formato antiguo */
-  shortId: string;
-  /** Cadena de fecha en formato YYYY-MM-DD */
-  date: string;
-  /** Objeto Date parseado a partir de la cadena de fecha */
-  datetime: Date;
-}
-
-/** Metadatos parseados del contenido markdown de la sesión */
-export interface SessionMetadata {
-  title: string | null;
-  date: string | null;
-  started: string | null;
-  lastUpdated: string | null;
-  project: string | null;
-  branch: string | null;
-  worktree: string | null;
-  completed: string[];
-  inProgress: string[];
-  notes: string;
-  context: string;
-}
-
-/** Estadísticas calculadas a partir del contenido de la sesión */
-export interface SessionStats {
-  totalItems: number;
-  completedItems: number;
-  inProgressItems: number;
-  lineCount: number;
-  hasNotes: boolean;
-  hasContext: boolean;
-}
-
-/** Objeto de sesión devuelto por getAllSessions y getSessionById */
-export interface Session extends SessionFilenameMeta {
-  /** Ruta completa en el sistema de archivos del archivo de sesión */
-  sessionPath: string;
-  /** Si el archivo tiene algún contenido */
-  hasContent?: boolean;
-  /** Tamaño del archivo en bytes */
-  size: number;
-  /** Fecha de última modificación */
-  modifiedTime: Date;
-  /** Fecha de creación del archivo (cae a ctime en Linux) */
-  createdTime: Date;
-  /** Contenido markdown de la sesión (solo cuando includeContent=true) */
-  content?: string | null;
-  /** Metadatos parseados (solo cuando includeContent=true) */
-  metadata?: SessionMetadata;
-  /** Estadísticas de la sesión (solo cuando includeContent=true) */
-  stats?: SessionStats;
-}
-
-/** Resultado paginado de getAllSessions */
-export interface SessionListResult {
-  sessions: Session[];
-  total: number;
-  offset: number;
-  limit: number;
-  hasMore: boolean;
-}
-
-export interface GetAllSessionsOptions {
-  /** Número máximo de sesiones a devolver (por defecto: 50) */
-  limit?: number;
-  /** Número de sesiones a saltar (por defecto: 0) */
-  offset?: number;
-  /** Filtrar por fecha en formato YYYY-MM-DD */
-  date?: string | null;
-  /** Buscar en el ID corto */
-  search?: string | null;
-}
-
-/**
- * Parsea el nombre de archivo de una sesión para extraer la fecha y el ID corto.
- * @returns Metadatos parseados, o null si el nombre no coincide con el patrón esperado
- */
-export function parseSessionFilename(filename: string): SessionFilenameMeta | null;
-
-/** Obtiene la ruta completa en el sistema de archivos para un nombre de archivo de sesión */
-export function getSessionPath(filename: string): string;
-
-/**
- * Lee el contenido markdown de la sesión desde disco.
- * @returns Cadena de contenido, o null si el archivo no existe
- */
-export function getSessionContent(sessionPath: string): string | null;
-
-/** Parsea los metadatos de la sesión a partir del contenido markdown */
-export function parseSessionMetadata(content: string | null): SessionMetadata;
-
-/**
- * Calcula estadísticas de una sesión.
- * Acepta una ruta de archivo (absoluta, terminada en .tmp) o una cadena de
- * contenido pre-leída. Admite rutas Unix (/ruta/a/session.tmp) y Windows
- * (C:\ruta\a\session.tmp).
- */
-export function getSessionStats(sessionPathOrContent: string): SessionStats;
-
-/** Obtiene el título de un archivo de sesión, o "Sesión sin título" si no tiene */
-export function getSessionTitle(sessionPath: string): string;
-
-/** Obtiene el tamaño del archivo en formato legible (p. ej. "1.2 KB") */
-export function getSessionSize(sessionPath: string): string;
-
-/** Obtiene todas las sesiones con filtrado y paginación opcionales */
-export function getAllSessions(options?: GetAllSessionsOptions): SessionListResult;
-
-/**
- * Busca una sesión por ID corto o nombre de archivo.
- * @param sessionId - Prefijo del ID corto, nombre de archivo completo o nombre sin .tmp
- * @param includeContent - Si se debe leer y parsear el contenido de la sesión
- */
-export function getSessionById(sessionId: string, includeContent?: boolean): Session | null;
-
-/** Escribe contenido markdown en un archivo de sesión */
-export function writeSessionContent(sessionPath: string, content: string): boolean;
-
-/** Anexa contenido a un archivo de sesión existente */
-export function appendSessionContent(sessionPath: string, content: string): boolean;
-
-/** Elimina un archivo de sesión */
-export function deleteSession(sessionPath: string): boolean;
-
-/** Verifica si un archivo de sesión existe y es un archivo regular */
-export function sessionExists(sessionPath: string): boolean;

package/vendor/theus-arsenal/scripts/lib/session-manager.js

@@ -1,555 +0,0 @@
-/**
- * Biblioteca de gestión de sesiones para Theus
- * Provee las operaciones CRUD centrales para listar, cargar y administrar sesiones.
- *
- * Las sesiones se guardan como archivos markdown en `<data home>/session-data/`
- * (por defecto `~/.theus/arsenal/session-data/`; THEUS_AGENT_DATA_HOME la
- * el motor lo define), con compatibilidad de lectura para el directorio
- * heredado `<data home>/sessions/`:
- * - YYYY-MM-DD-session.tmp (formato antiguo)
- * - YYYY-MM-DD-<id-corto>-session.tmp (formato nuevo)
- *
- * Nota: estas sesiones son los resúmenes markdown del arsenal (guardar/reanudar
- * sesión), no las transcripciones nativas de Theus, que viven en
- * `~/.theus/projects/<dir-escapado>/<session_id>.jsonl`.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const {
-  getSessionsDir,
-  getSessionSearchDirs,
-  readFile,
-  log
-} = require('./utils');
-
-// Patrón del nombre de archivo de sesión: YYYY-MM-DD-[id-de-sesion]-session.tmp
-// El id de sesión es opcional (formato antiguo) y puede incluir letras, dígitos,
-// guiones bajos y guiones, pero no puede empezar con guion.
-// Coincide con: "2026-02-01-session.tmp", "2026-02-01-a1b2c3d4-session.tmp",
-// "2026-02-01-frontend-worktree-1-session.tmp" y
-// "2026-02-01-ChezMoi_2-session.tmp"
-const SESSION_FILENAME_REGEX = /^(\d{4}-\d{2}-\d{2})(?:-([a-zA-Z0-9_][a-zA-Z0-9_-]*))?-session\.tmp$/;
-
-/**
- * Resuelve la fecha de creación de un archivo, prefiriendo birthtime pero
- * cayendo a ctime cuando birthtime no está disponible. Algunos sistemas de
- * archivos (p. ej. overlayfs en contenedores) reportan birthtime como epoch 0;
- * un objeto Date siempre es truthy, así que `birthtime || ctime` nunca haría
- * el fallback. Se compara en milisegundos en su lugar.
- * @param {import('fs').Stats} stats
- * @returns {Date}
- */
-function resolveCreatedTime(stats) {
-  return stats.birthtimeMs > 0 ? stats.birthtime : stats.ctime;
-}
-
-/**
- * Parsea el nombre de archivo de una sesión para extraer sus metadatos
- * @param {string} filename - Nombre de archivo de sesión (p. ej. "2026-01-17-abc123-session.tmp" o "2026-01-17-session.tmp")
- * @returns {object|null} Metadatos parseados o null si es inválido
- */
-function parseSessionFilename(filename) {
-  if (!filename || typeof filename !== 'string') return null;
-  const match = filename.match(SESSION_FILENAME_REGEX);
-  if (!match) return null;
-
-  const dateStr = match[1];
-
-  // Validar que los componentes de la fecha sean válidos en el calendario (no solo el formato)
-  const [year, month, day] = dateStr.split('-').map(Number);
-  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
-  // Rechazar fechas imposibles como 31 de febrero o 31 de abril — el constructor
-  // de Date desborda los días inválidos (p. ej. 31 feb → 3 mar), así que se
-  // verifica que el mes haga el viaje de ida y vuelta
-  const d = new Date(year, month - 1, day);
-  if (d.getMonth() !== month - 1 || d.getDate() !== day) return null;
-
-  // match[2] es undefined para el formato antiguo (sin ID)
-  const shortId = match[2] || 'no-id';
-
-  return {
-    filename,
-    shortId,
-    date: dateStr,
-    // Usar el constructor en hora local (consistente con la validación anterior)
-    // new Date(dateStr) interpreta YYYY-MM-DD como medianoche UTC, que se
-    // muestra como el día anterior en zonas horarias con desfase UTC negativo
-    datetime: new Date(year, month - 1, day)
-  };
-}
-
-/**
- * Obtiene la ruta completa a un archivo de sesión
- * @param {string} filename - Nombre de archivo de sesión
- * @returns {string} Ruta completa al archivo de sesión
- */
-function getSessionPath(filename) {
-  return path.join(getSessionsDir(), filename);
-}
-
-function getSessionCandidates(options = {}) {
-  const {
-    date = null,
-    search = null
-  } = options;
-
-  const candidates = [];
-
-  for (const sessionsDir of getSessionSearchDirs()) {
-    if (!fs.existsSync(sessionsDir)) {
-      continue;
-    }
-
-    let entries;
-    try {
-      entries = fs.readdirSync(sessionsDir, { withFileTypes: true });
-    } catch (error) {
-      log(`[SessionManager] Error al leer el directorio de sesiones ${sessionsDir}: ${error.message}`);
-      continue;
-    }
-
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.endsWith('.tmp')) continue;
-
-      const filename = entry.name;
-      const metadata = parseSessionFilename(filename);
-
-      if (!metadata) continue;
-      if (date && metadata.date !== date) continue;
-      if (search && !metadata.shortId.includes(search)) continue;
-
-      const sessionPath = path.join(sessionsDir, filename);
-
-      let stats;
-      try {
-        stats = fs.statSync(sessionPath);
-      } catch (error) {
-        log(`[SessionManager] Error al consultar la sesión ${sessionPath}: ${error.message}`);
-        continue;
-      }
-
-      candidates.push({
-        ...metadata,
-        sessionPath,
-        hasContent: stats.size > 0,
-        size: stats.size,
-        modifiedTime: stats.mtime,
-        createdTime: resolveCreatedTime(stats)
-      });
-    }
-  }
-
-  const deduped = [];
-  const seenFilenames = new Set();
-
-  for (const session of candidates) {
-    if (seenFilenames.has(session.filename)) {
-      continue;
-    }
-    seenFilenames.add(session.filename);
-    deduped.push(session);
-  }
-
-  deduped.sort((a, b) => b.modifiedTime - a.modifiedTime);
-  return deduped;
-}
-
-function buildSessionRecord(sessionPath, metadata) {
-  let stats;
-  try {
-    stats = fs.statSync(sessionPath);
-  } catch (error) {
-    log(`[SessionManager] Error al consultar la sesión ${sessionPath}: ${error.message}`);
-    return null;
-  }
-
-  return {
-    ...metadata,
-    sessionPath,
-    hasContent: stats.size > 0,
-    size: stats.size,
-    modifiedTime: stats.mtime,
-    createdTime: resolveCreatedTime(stats)
-  };
-}
-
-function sessionMatchesId(metadata, normalizedSessionId) {
-  const filename = metadata.filename;
-  const shortIdMatch = metadata.shortId !== 'no-id' && metadata.shortId.startsWith(normalizedSessionId);
-  const filenameMatch = filename === normalizedSessionId || filename === `${normalizedSessionId}.tmp`;
-  const noIdMatch = metadata.shortId === 'no-id' && filename === `${normalizedSessionId}-session.tmp`;
-
-  return shortIdMatch || filenameMatch || noIdMatch;
-}
-
-function getMatchingSessionCandidates(normalizedSessionId) {
-  const matches = [];
-  const seenFilenames = new Set();
-
-  for (const sessionsDir of getSessionSearchDirs()) {
-    if (!fs.existsSync(sessionsDir)) {
-      continue;
-    }
-
-    let entries;
-    try {
-      entries = fs.readdirSync(sessionsDir, { withFileTypes: true });
-    } catch (error) {
-      log(`[SessionManager] Error al leer el directorio de sesiones ${sessionsDir}: ${error.message}`);
-      continue;
-    }
-
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.endsWith('.tmp')) continue;
-
-      const metadata = parseSessionFilename(entry.name);
-      if (!metadata || !sessionMatchesId(metadata, normalizedSessionId)) {
-        continue;
-      }
-
-      if (seenFilenames.has(metadata.filename)) {
-        continue;
-      }
-
-      const sessionPath = path.join(sessionsDir, metadata.filename);
-      const sessionRecord = buildSessionRecord(sessionPath, metadata);
-      if (!sessionRecord) {
-        continue;
-      }
-
-      seenFilenames.add(metadata.filename);
-      matches.push(sessionRecord);
-    }
-  }
-
-  matches.sort((a, b) => b.modifiedTime - a.modifiedTime);
-  return matches;
-}
-
-/**
- * Lee y parsea el contenido markdown de una sesión
- * @param {string} sessionPath - Ruta completa al archivo de sesión
- * @returns {string|null} Contenido de la sesión o null si no se encuentra
- */
-function getSessionContent(sessionPath) {
-  return readFile(sessionPath);
-}
-
-/**
- * Parsea los metadatos de una sesión a partir de su contenido markdown.
- * Los marcadores se aceptan tanto en español como en inglés para mantener
- * compatibilidad con sesiones guardadas en cualquiera de los dos idiomas.
- * @param {string} content - Contenido markdown de la sesión
- * @returns {object} Metadatos parseados
- */
-function parseSessionMetadata(content) {
-  const metadata = {
-    title: null,
-    date: null,
-    started: null,
-    lastUpdated: null,
-    project: null,
-    branch: null,
-    worktree: null,
-    completed: [],
-    inProgress: [],
-    notes: '',
-    context: ''
-  };
-
-  if (!content) return metadata;
-
-  // Extraer el título del primer encabezado
-  const titleMatch = content.match(/^#\s+(.+)$/m);
-  if (titleMatch) {
-    metadata.title = titleMatch[1].trim();
-  }
-
-  // Extraer la fecha
-  const dateMatch = content.match(/\*\*(?:Fecha|Date):\*\*\s*(\d{4}-\d{2}-\d{2})/);
-  if (dateMatch) {
-    metadata.date = dateMatch[1];
-  }
-
-  // Extraer la hora de inicio
-  const startedMatch = content.match(/\*\*(?:Inicio|Started):\*\*\s*([\d:]+)/);
-  if (startedMatch) {
-    metadata.started = startedMatch[1];
-  }
-
-  // Extraer la última actualización
-  const updatedMatch = content.match(/\*\*(?:Última actualización|Last Updated):\*\*\s*([\d:]+)/);
-  if (updatedMatch) {
-    metadata.lastUpdated = updatedMatch[1];
-  }
-
-  // Extraer metadatos del panel de control
-  const projectMatch = content.match(/\*\*(?:Proyecto|Project):\*\*\s*(.+)$/m);
-  if (projectMatch) {
-    metadata.project = projectMatch[1].trim();
-  }
-
-  const branchMatch = content.match(/\*\*(?:Rama|Branch):\*\*\s*(.+)$/m);
-  if (branchMatch) {
-    metadata.branch = branchMatch[1].trim();
-  }
-
-  const worktreeMatch = content.match(/\*\*Worktree:\*\*\s*(.+)$/m);
-  if (worktreeMatch) {
-    metadata.worktree = worktreeMatch[1].trim();
-  }
-
-  // Extraer los ítems completados
-  const completedSection = content.match(/### (?:Completado|Completed)\s*\n([\s\S]*?)(?=###|\n\n|$)/);
-  if (completedSection) {
-    const items = completedSection[1].match(/- \[x\]\s*(.+)/g);
-    if (items) {
-      metadata.completed = items.map(item => item.replace(/- \[x\]\s*/, '').trim());
-    }
-  }
-
-  // Extraer los ítems en progreso
-  const progressSection = content.match(/### (?:En progreso|In Progress)\s*\n([\s\S]*?)(?=###|\n\n|$)/);
-  if (progressSection) {
-    const items = progressSection[1].match(/- \[ \]\s*(.+)/g);
-    if (items) {
-      metadata.inProgress = items.map(item => item.replace(/- \[ \]\s*/, '').trim());
-    }
-  }
-
-  // Extraer las notas
-  const notesSection = content.match(/### (?:Notas para la próxima sesión|Notes for Next Session)\s*\n([\s\S]*?)(?=###|\n\n|$)/);
-  if (notesSection) {
-    metadata.notes = notesSection[1].trim();
-  }
-
-  // Extraer el contexto a cargar
-  const contextSection = content.match(/### (?:Contexto a cargar|Context to Load)\s*\n```\n([\s\S]*?)```/);
-  if (contextSection) {
-    metadata.context = contextSection[1].trim();
-  }
-
-  return metadata;
-}
-
-/**
- * Calcula estadísticas de una sesión
- * @param {string} sessionPathOrContent - Ruta completa al archivo de sesión, O
- *   la cadena de contenido ya leída (para evitar lecturas de disco redundantes
- *   cuando el llamador ya tiene el contenido cargado).
- * @returns {object} Objeto de estadísticas
- */
-function getSessionStats(sessionPathOrContent) {
-  // Acepta una cadena de contenido pre-leída para evitar lecturas redundantes.
-  // Si el argumento parece una ruta de archivo (sin saltos de línea, termina
-  // en .tmp, empieza con / en Unix o con letra de unidad en Windows), se lee
-  // del disco. En caso contrario se trata como contenido.
-  const looksLikePath = typeof sessionPathOrContent === 'string' &&
-    !sessionPathOrContent.includes('\n') &&
-    sessionPathOrContent.endsWith('.tmp') &&
-    (sessionPathOrContent.startsWith('/') || /^[A-Za-z]:[/\\]/.test(sessionPathOrContent));
-  const content = looksLikePath
-    ? getSessionContent(sessionPathOrContent)
-    : sessionPathOrContent;
-
-  const metadata = parseSessionMetadata(content);
-
-  return {
-    totalItems: metadata.completed.length + metadata.inProgress.length,
-    completedItems: metadata.completed.length,
-    inProgressItems: metadata.inProgress.length,
-    lineCount: content ? content.split('\n').length : 0,
-    hasNotes: !!metadata.notes,
-    hasContext: !!metadata.context
-  };
-}
-
-/**
- * Obtiene todas las sesiones con filtrado y paginación opcionales
- * @param {object} options - Objeto de opciones
- * @param {number} options.limit - Número máximo de sesiones a devolver
- * @param {number} options.offset - Número de sesiones a saltar
- * @param {string} options.date - Filtrar por fecha (formato YYYY-MM-DD)
- * @param {string} options.search - Buscar en el ID corto
- * @returns {object} Objeto con el arreglo de sesiones e información de paginación
- */
-function getAllSessions(options = {}) {
-  const {
-    limit: rawLimit = 50,
-    offset: rawOffset = 0,
-    date = null,
-    search = null
-  } = options;
-
-  // Acotar offset y limit a enteros no negativos seguros.
-  // Sin esto, un offset negativo hace que slice() cuente desde el final,
-  // y los valores NaN hacen que slice() devuelva vacío o resultados inesperados.
-  // Nota: no se puede usar `|| valorPorDefecto` porque 0 es falsy — usar isNaN.
-  const offsetNum = Number(rawOffset);
-  const offset = Number.isNaN(offsetNum) ? 0 : Math.max(0, Math.floor(offsetNum));
-  const limitNum = Number(rawLimit);
-  const limit = Number.isNaN(limitNum) ? 50 : Math.max(1, Math.floor(limitNum));
-
-  const sessions = getSessionCandidates({ date, search });
-
-  if (sessions.length === 0) {
-    return { sessions: [], total: 0, offset, limit, hasMore: false };
-  }
-
-  // Aplicar paginación
-  const paginatedSessions = sessions.slice(offset, offset + limit);
-
-  return {
-    sessions: paginatedSessions,
-    total: sessions.length,
-    offset,
-    limit,
-    hasMore: offset + limit < sessions.length
-  };
-}
-
-/**
- * Obtiene una sesión individual por ID (ID corto o ruta completa)
- * @param {string} sessionId - ID corto o nombre de archivo de la sesión
- * @param {boolean} includeContent - Incluir el contenido de la sesión
- * @returns {object|null} Objeto de sesión o null si no se encuentra
- */
-function getSessionById(sessionId, includeContent = false) {
-  if (typeof sessionId !== 'string') {
-    return null;
-  }
-
-  const normalizedSessionId = sessionId.trim();
-  if (!normalizedSessionId) {
-    return null;
-  }
-
-  const sessions = getMatchingSessionCandidates(normalizedSessionId);
-
-  for (const session of sessions) {
-    const sessionRecord = { ...session };
-
-    if (includeContent) {
-      sessionRecord.content = getSessionContent(sessionRecord.sessionPath);
-      sessionRecord.metadata = parseSessionMetadata(sessionRecord.content);
-      // Pasar el contenido pre-leído para evitar una lectura de disco redundante
-      sessionRecord.stats = getSessionStats(sessionRecord.content || '');
-    }
-
-    return sessionRecord;
-  }
-
-  return null;
-}
-
-/**
- * Obtiene el título de la sesión a partir de su contenido
- * @param {string} sessionPath - Ruta completa al archivo de sesión
- * @returns {string} Título o texto por defecto
- */
-function getSessionTitle(sessionPath) {
-  const content = getSessionContent(sessionPath);
-  const metadata = parseSessionMetadata(content);
-
-  return metadata.title || 'Sesión sin título';
-}
-
-/**
- * Formatea el tamaño de la sesión en un formato legible
- * @param {string} sessionPath - Ruta completa al archivo de sesión
- * @returns {string} Tamaño formateado (p. ej. "1.2 KB")
- */
-function getSessionSize(sessionPath) {
-  let stats;
-  try {
-    stats = fs.statSync(sessionPath);
-  } catch {
-    return '0 B';
-  }
-  const size = stats.size;
-
-  if (size < 1024) return `${size} B`;
-  if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)} KB`;
-  return `${(size / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-/**
- * Escribe el contenido de una sesión en un archivo
- * @param {string} sessionPath - Ruta completa al archivo de sesión
- * @param {string} content - Contenido markdown a escribir
- * @returns {boolean} Estado de éxito
- */
-function writeSessionContent(sessionPath, content) {
-  try {
-    fs.writeFileSync(sessionPath, content, 'utf8');
-    return true;
-  } catch (err) {
-    log(`[SessionManager] Error al escribir la sesión: ${err.message}`);
-    return false;
-  }
-}
-
-/**
- * Anexa contenido a una sesión
- * @param {string} sessionPath - Ruta completa al archivo de sesión
- * @param {string} content - Contenido a anexar
- * @returns {boolean} Estado de éxito
- */
-function appendSessionContent(sessionPath, content) {
-  try {
-    fs.appendFileSync(sessionPath, content, 'utf8');
-    return true;
-  } catch (err) {
-    log(`[SessionManager] Error al anexar a la sesión: ${err.message}`);
-    return false;
-  }
-}
-
-/**
- * Elimina un archivo de sesión
- * @param {string} sessionPath - Ruta completa al archivo de sesión
- * @returns {boolean} Estado de éxito
- */
-function deleteSession(sessionPath) {
-  try {
-    if (fs.existsSync(sessionPath)) {
-      fs.unlinkSync(sessionPath);
-      return true;
-    }
-    return false;
-  } catch (err) {
-    log(`[SessionManager] Error al eliminar la sesión: ${err.message}`);
-    return false;
-  }
-}
-
-/**
- * Verifica si una sesión existe
- * @param {string} sessionPath - Ruta completa al archivo de sesión
- * @returns {boolean} true si la sesión existe
- */
-function sessionExists(sessionPath) {
-  try {
-    return fs.statSync(sessionPath).isFile();
-  } catch {
-    return false;
-  }
-}
-
-module.exports = {
-  parseSessionFilename,
-  getSessionPath,
-  getSessionContent,
-  parseSessionMetadata,
-  getSessionStats,
-  getSessionTitle,
-  getSessionSize,
-  getAllSessions,
-  getSessionById,
-  writeSessionContent,
-  appendSessionContent,
-  deleteSession,
-  sessionExists
-};