ccjk 2.4.3 → 2.5.0

package/dist/chunks/session.mjs

@@ -1,14 +1,304 @@
 import { existsSync } from 'node:fs';
-import { mkdir, writeFile, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { mkdir, writeFile, readFile, readdir, rm, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join as join$1 } from 'node:path';
 import process__default from 'node:process';
 import ansis from 'ansis';
 import inquirer from 'inquirer';
+import { join } from 'pathe';
 
-const SESSIONS_DIR = join(homedir(), ".ccjk", "sessions");
-const CCJK_DIR = join(homedir(), ".ccjk");
-const CLAUDE_DIR = join(homedir(), ".claude");
+class SessionManager {
+  sessionsDir;
+  autoCleanupDays;
+  constructor(options = {}) {
+    this.sessionsDir = options.sessionsDir || join(homedir(), ".ccjk", "sessions");
+    this.autoCleanupDays = options.autoCleanupDays || 30;
+  }
+  /**
+   * Initialize sessions directory
+   */
+  async ensureSessionsDir() {
+    if (!existsSync(this.sessionsDir)) {
+      await mkdir(this.sessionsDir, { recursive: true });
+    }
+  }
+  /**
+   * Generate unique session ID
+   */
+  generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Get session file path
+   */
+  getSessionPath(sessionId) {
+    return join(this.sessionsDir, `${sessionId}.json`);
+  }
+  /**
+   * Create a new session
+   */
+  async createSession(name, provider, apiKey, options) {
+    await this.ensureSessionsDir();
+    const session = {
+      id: this.generateSessionId(),
+      name,
+      provider,
+      apiKey,
+      apiUrl: options?.apiUrl,
+      model: options?.model,
+      codeType: options?.codeType,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastUsedAt: /* @__PURE__ */ new Date(),
+      history: [],
+      metadata: options?.metadata
+    };
+    await this.saveSession(session);
+    return session;
+  }
+  /**
+   * Save session to storage
+   */
+  async saveSession(session) {
+    await this.ensureSessionsDir();
+    const sessionPath = this.getSessionPath(session.id);
+    const sessionData = {
+      ...session,
+      createdAt: session.createdAt.toISOString(),
+      lastUsedAt: session.lastUsedAt.toISOString(),
+      history: session.history.map((entry) => ({
+        ...entry,
+        timestamp: entry.timestamp.toISOString()
+      }))
+    };
+    await writeFile(sessionPath, JSON.stringify(sessionData, null, 2), "utf-8");
+  }
+  /**
+   * Load session by ID or name
+   */
+  async loadSession(nameOrId) {
+    await this.ensureSessionsDir();
+    let sessionPath = this.getSessionPath(nameOrId);
+    if (!existsSync(sessionPath)) {
+      const sessions = await this.listSessions();
+      const found = sessions.find((s) => s.name === nameOrId);
+      if (!found) {
+        return null;
+      }
+      sessionPath = this.getSessionPath(found.id);
+    }
+    try {
+      const content = await readFile(sessionPath, "utf-8");
+      const data = JSON.parse(content);
+      return {
+        ...data,
+        createdAt: new Date(data.createdAt),
+        lastUsedAt: new Date(data.lastUsedAt),
+        history: data.history.map((entry) => ({
+          ...entry,
+          timestamp: new Date(entry.timestamp)
+        }))
+      };
+    } catch (error) {
+      console.error(`Failed to load session ${nameOrId}:`, error);
+      return null;
+    }
+  }
+  /**
+   * List all sessions
+   */
+  async listSessions(options = {}) {
+    await this.ensureSessionsDir();
+    try {
+      const files = await readdir(this.sessionsDir);
+      const sessionFiles = files.filter((f) => f.endsWith(".json"));
+      const sessions = [];
+      for (const file of sessionFiles) {
+        const sessionPath = join(this.sessionsDir, file);
+        try {
+          const content = await readFile(sessionPath, "utf-8");
+          const data = JSON.parse(content);
+          sessions.push({
+            ...data,
+            createdAt: new Date(data.createdAt),
+            lastUsedAt: new Date(data.lastUsedAt),
+            history: data.history.map((entry) => ({
+              ...entry,
+              timestamp: new Date(entry.timestamp)
+            }))
+          });
+        } catch (error) {
+          console.error(`Failed to load session file ${file}:`, error);
+        }
+      }
+      const sortBy = options.sortBy || "lastUsedAt";
+      const order = options.order || "desc";
+      sessions.sort((a, b) => {
+        let comparison = 0;
+        if (sortBy === "name") {
+          comparison = (a.name || a.id).localeCompare(b.name || b.id);
+        } else if (sortBy === "createdAt") {
+          comparison = a.createdAt.getTime() - b.createdAt.getTime();
+        } else if (sortBy === "lastUsedAt") {
+          comparison = a.lastUsedAt.getTime() - b.lastUsedAt.getTime();
+        }
+        return order === "asc" ? comparison : -comparison;
+      });
+      if (options.limit && options.limit > 0) {
+        return sessions.slice(0, options.limit);
+      }
+      return sessions;
+    } catch (error) {
+      console.error("Failed to list sessions:", error);
+      return [];
+    }
+  }
+  /**
+   * Delete session by ID or name
+   */
+  async deleteSession(nameOrId) {
+    const session = await this.loadSession(nameOrId);
+    if (!session) {
+      return false;
+    }
+    const sessionPath = this.getSessionPath(session.id);
+    try {
+      const fs = await import('node:fs/promises');
+      await fs.unlink(sessionPath);
+      return true;
+    } catch (error) {
+      console.error(`Failed to delete session ${nameOrId}:`, error);
+      return false;
+    }
+  }
+  /**
+   * Rename session
+   */
+  async renameSession(oldName, newName) {
+    const session = await this.loadSession(oldName);
+    if (!session) {
+      return false;
+    }
+    session.name = newName;
+    session.lastUsedAt = /* @__PURE__ */ new Date();
+    await this.saveSession(session);
+    return true;
+  }
+  /**
+   * Add history entry to session
+   */
+  async addHistoryEntry(sessionId, role, content, tokens) {
+    const session = await this.loadSession(sessionId);
+    if (!session) {
+      return false;
+    }
+    session.history.push({
+      timestamp: /* @__PURE__ */ new Date(),
+      role,
+      content,
+      tokens
+    });
+    session.lastUsedAt = /* @__PURE__ */ new Date();
+    await this.saveSession(session);
+    return true;
+  }
+  /**
+   * Update session metadata
+   */
+  async updateSession(sessionId, updates) {
+    const session = await this.loadSession(sessionId);
+    if (!session) {
+      return false;
+    }
+    Object.assign(session, updates);
+    session.lastUsedAt = /* @__PURE__ */ new Date();
+    await this.saveSession(session);
+    return true;
+  }
+  /**
+   * Clean up old sessions (older than autoCleanupDays)
+   */
+  async cleanupOldSessions() {
+    const sessions = await this.listSessions();
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - this.autoCleanupDays);
+    let deletedCount = 0;
+    for (const session of sessions) {
+      if (session.lastUsedAt < cutoffDate) {
+        const deleted = await this.deleteSession(session.id);
+        if (deleted) {
+          deletedCount++;
+        }
+      }
+    }
+    return deletedCount;
+  }
+  /**
+   * Get session statistics
+   */
+  async getStatistics() {
+    const sessions = await this.listSessions();
+    if (sessions.length === 0) {
+      return {
+        totalSessions: 0,
+        totalHistoryEntries: 0
+      };
+    }
+    const totalHistoryEntries = sessions.reduce((sum, s) => sum + s.history.length, 0);
+    const sortedByCreated = [...sessions].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    const sortedByUsed = [...sessions].sort((a, b) => b.lastUsedAt.getTime() - a.lastUsedAt.getTime());
+    return {
+      totalSessions: sessions.length,
+      totalHistoryEntries,
+      oldestSession: sortedByCreated[0]?.createdAt,
+      newestSession: sortedByCreated[sortedByCreated.length - 1]?.createdAt,
+      mostRecentlyUsed: sortedByUsed[0]?.lastUsedAt
+    };
+  }
+  /**
+   * Export session to JSON
+   */
+  async exportSession(sessionId) {
+    const session = await this.loadSession(sessionId);
+    if (!session) {
+      return null;
+    }
+    return JSON.stringify(session, null, 2);
+  }
+  /**
+   * Import session from JSON
+   */
+  async importSession(jsonData) {
+    try {
+      const data = JSON.parse(jsonData);
+      const session = {
+        ...data,
+        id: this.generateSessionId(),
+        createdAt: new Date(data.createdAt),
+        lastUsedAt: /* @__PURE__ */ new Date(),
+        history: data.history.map((entry) => ({
+          ...entry,
+          timestamp: new Date(entry.timestamp)
+        }))
+      };
+      await this.saveSession(session);
+      return session;
+    } catch (error) {
+      console.error("Failed to import session:", error);
+      return null;
+    }
+  }
+}
+let sessionManagerInstance = null;
+function getSessionManager(options) {
+  if (!sessionManagerInstance) {
+    sessionManagerInstance = new SessionManager(options);
+  }
+  return sessionManagerInstance;
+}
+
+const SESSIONS_DIR = join$1(homedir(), ".ccjk", "sessions");
+const CCJK_DIR = join$1(homedir(), ".ccjk");
+const CLAUDE_DIR = join$1(homedir(), ".claude");
 async function saveSession() {
   try {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -26,7 +316,7 @@ async function saveSession() {
     if (!existsSync(SESSIONS_DIR)) {
       await mkdir(SESSIONS_DIR, { recursive: true });
     }
-    const sessionFile = join(SESSIONS_DIR, `${sessionId}.json`);
+    const sessionFile = join$1(SESSIONS_DIR, `${sessionId}.json`);
     await writeFile(sessionFile, JSON.stringify(metadata, null, 2));
     console.log(ansis.green(`\u2714 Session saved: ${sessionId}`));
     if (description) {
@@ -38,28 +328,41 @@ async function saveSession() {
 }
 async function listSessions() {
   try {
-    if (!existsSync(SESSIONS_DIR)) {
-      console.log(ansis.yellow("No sessions found"));
-      return;
-    }
-    const files = await readdir(SESSIONS_DIR);
-    const sessions = files.filter((f) => f.endsWith(".json"));
+    const sessionManager = getSessionManager();
+    const sessions = await sessionManager.listSessions();
     if (sessions.length === 0) {
       console.log(ansis.yellow("No sessions found"));
+      console.log(ansis.gray(`
+Create a new session with: ${ansis.cyan("ccjk session create")}`));
       return;
     }
     console.log(ansis.cyan.bold("\n\u{1F4CB} Saved Sessions:\n"));
-    for (const file of sessions) {
-      const content = await readFile(join(SESSIONS_DIR, file), "utf-8");
-      const metadata = JSON.parse(content);
-      const date = new Date(metadata.timestamp).toLocaleString();
-      console.log(ansis.white(`  ${metadata.id}`));
-      console.log(ansis.gray(`    ${date}`));
-      if (metadata.description) {
-        console.log(ansis.gray(`    ${metadata.description}`));
+    const sortedSessions = [...sessions].sort((a, b) => {
+      const aTime = a.lastAccessedAt?.getTime() || a.createdAt.getTime();
+      const bTime = b.lastAccessedAt?.getTime() || b.createdAt.getTime();
+      return bTime - aTime;
+    });
+    for (const session of sortedSessions) {
+      const nameDisplay = session.name ? ansis.cyan(session.name) : ansis.gray("(unnamed)");
+      const idDisplay = ansis.gray(`[${session.id.substring(0, 8)}]`);
+      console.log(`  ${nameDisplay} ${idDisplay}`);
+      if (session.provider) {
+        console.log(ansis.gray(`    Provider: ${session.provider}`));
+      }
+      const createdDate = session.createdAt.toLocaleString();
+      console.log(ansis.gray(`    Created: ${createdDate}`));
+      if (session.lastAccessedAt) {
+        const accessedDate = session.lastAccessedAt.toLocaleString();
+        console.log(ansis.gray(`    Last accessed: ${accessedDate}`));
+      }
+      if (session.history.length > 0) {
+        console.log(ansis.gray(`    History: ${session.history.length} entries`));
       }
       console.log("");
     }
+    console.log(ansis.gray(`Total: ${sessions.length} session(s)`));
+    console.log(ansis.gray(`
+Use ${ansis.cyan("ccjk --resume <name|id>")} to resume a session`));
   } catch (error) {
     console.error(ansis.red("Failed to list sessions:"), error);
   }
@@ -79,7 +382,7 @@ async function restoreSession(sessionId) {
     if (!sessionId) {
       const choices = await Promise.all(
         sessions.map(async (file) => {
-          const content2 = await readFile(join(SESSIONS_DIR, file), "utf-8");
+          const content2 = await readFile(join$1(SESSIONS_DIR, file), "utf-8");
           const metadata2 = JSON.parse(content2);
           const date = new Date(metadata2.timestamp).toLocaleString();
           return {
@@ -96,7 +399,7 @@ async function restoreSession(sessionId) {
       });
       sessionId = selected;
     }
-    const sessionFile = join(SESSIONS_DIR, `${sessionId}.json`);
+    const sessionFile = join$1(SESSIONS_DIR, `${sessionId}.json`);
     if (!existsSync(sessionFile)) {
       console.log(ansis.red(`Session not found: ${sessionId}`));
       return;
@@ -126,7 +429,7 @@ async function exportSession(sessionId) {
     if (!sessionId) {
       const choices = await Promise.all(
         sessions.map(async (file) => {
-          const content2 = await readFile(join(SESSIONS_DIR, file), "utf-8");
+          const content2 = await readFile(join$1(SESSIONS_DIR, file), "utf-8");
           const metadata2 = JSON.parse(content2);
           const date = new Date(metadata2.timestamp).toLocaleString();
           return {
@@ -143,7 +446,7 @@ async function exportSession(sessionId) {
       });
       sessionId = selected;
     }
-    const sessionFile = join(SESSIONS_DIR, `${sessionId}.json`);
+    const sessionFile = join$1(SESSIONS_DIR, `${sessionId}.json`);
     if (!existsSync(sessionFile)) {
       console.log(ansis.red(`Session not found: ${sessionId}`));
       return;
@@ -159,7 +462,7 @@ ${metadata.description ? `**Description:** ${metadata.description}
 
 Session data would be exported here.
 `;
-    const outputFile = join(process__default.cwd(), `${sessionId}.md`);
+    const outputFile = join$1(process__default.cwd(), `${sessionId}.md`);
     await writeFile(outputFile, markdown);
     console.log(ansis.green(`\u2714 Session exported: ${outputFile}`));
   } catch (error) {
@@ -181,7 +484,7 @@ async function getDirSize(dirPath) {
   try {
     const entries = await readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join(dirPath, entry.name);
+      const fullPath = join$1(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirSize(fullPath);
       } else {
@@ -200,7 +503,7 @@ async function countFiles(dirPath) {
   try {
     const entries = await readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join(dirPath, entry.name);
+      const fullPath = join$1(dirPath, entry.name);
       if (entry.isDirectory()) {
         count += await countFiles(fullPath);
       } else {
@@ -214,21 +517,21 @@ async function countFiles(dirPath) {
 async function analyzeCleanupTargets() {
   const targets = [];
   const ccjkCacheDirs = [
-    { name: "ccjk/cache", path: join(CCJK_DIR, "cache"), desc: "General cache files", safe: true },
-    { name: "ccjk/sessions", path: join(CCJK_DIR, "sessions"), desc: "Saved session data", safe: true },
-    { name: "ccjk/logs", path: join(CCJK_DIR, "logs"), desc: "Log files", safe: true },
-    { name: "ccjk/temp", path: join(CCJK_DIR, "temp"), desc: "Temporary files", safe: true }
+    { name: "ccjk/cache", path: join$1(CCJK_DIR, "cache"), desc: "General cache files", safe: true },
+    { name: "ccjk/sessions", path: join$1(CCJK_DIR, "sessions"), desc: "Saved session data", safe: true },
+    { name: "ccjk/logs", path: join$1(CCJK_DIR, "logs"), desc: "Log files", safe: true },
+    { name: "ccjk/temp", path: join$1(CCJK_DIR, "temp"), desc: "Temporary files", safe: true }
   ];
   const claudeDirs = [
-    { name: "claude/projects", path: join(CLAUDE_DIR, "projects"), desc: "Claude project caches", safe: true },
-    { name: "claude/debug", path: join(CLAUDE_DIR, "debug"), desc: "Debug logs and traces", safe: true },
-    { name: "claude/file-history", path: join(CLAUDE_DIR, "file-history"), desc: "File edit history", safe: true },
-    { name: "claude/shell-snapshots", path: join(CLAUDE_DIR, "shell-snapshots"), desc: "Shell state snapshots", safe: true },
-    { name: "claude/paste-cache", path: join(CLAUDE_DIR, "paste-cache"), desc: "Clipboard paste cache", safe: true },
-    { name: "claude/todos", path: join(CLAUDE_DIR, "todos"), desc: "Todo list files", safe: false },
-    { name: "claude/plans", path: join(CLAUDE_DIR, "plans"), desc: "Plan files", safe: true },
-    { name: "claude/session-env", path: join(CLAUDE_DIR, "session-env"), desc: "Session environment data", safe: true },
-    { name: "claude/ide", path: join(CLAUDE_DIR, "ide"), desc: "IDE integration cache", safe: true }
+    { name: "claude/projects", path: join$1(CLAUDE_DIR, "projects"), desc: "Claude project caches", safe: true },
+    { name: "claude/debug", path: join$1(CLAUDE_DIR, "debug"), desc: "Debug logs and traces", safe: true },
+    { name: "claude/file-history", path: join$1(CLAUDE_DIR, "file-history"), desc: "File edit history", safe: true },
+    { name: "claude/shell-snapshots", path: join$1(CLAUDE_DIR, "shell-snapshots"), desc: "Shell state snapshots", safe: true },
+    { name: "claude/paste-cache", path: join$1(CLAUDE_DIR, "paste-cache"), desc: "Clipboard paste cache", safe: true },
+    { name: "claude/todos", path: join$1(CLAUDE_DIR, "todos"), desc: "Todo list files", safe: false },
+    { name: "claude/plans", path: join$1(CLAUDE_DIR, "plans"), desc: "Plan files", safe: true },
+    { name: "claude/session-env", path: join$1(CLAUDE_DIR, "session-env"), desc: "Session environment data", safe: true },
+    { name: "claude/ide", path: join$1(CLAUDE_DIR, "ide"), desc: "IDE integration cache", safe: true }
   ];
   for (const dir of [...ccjkCacheDirs, ...claudeDirs]) {
     if (existsSync(dir.path)) {
@@ -347,9 +650,149 @@ async function sessionStatus() {
     console.log(`${ansis.white.bold("Total".padEnd(24))} ${ansis.cyan.bold(formatBytes(totalSize).padStart(10))} ${ansis.gray(String(totalFiles).padStart(8))}`);
     console.log("");
     console.log(ansis.gray(`Run ${ansis.cyan("ccjk session cleanup")} to free up space`));
+    const sessionManager = getSessionManager();
+    const stats = await sessionManager.getStatistics();
+    if (stats.totalSessions > 0) {
+      console.log(ansis.cyan.bold("\n\u{1F4DD} Session Statistics\n"));
+      console.log(ansis.white(`Total Sessions: ${ansis.yellow(String(stats.totalSessions))}`));
+      console.log(ansis.white(`Total History Entries: ${ansis.yellow(String(stats.totalHistoryEntries))}`));
+      if (stats.oldestSession) {
+        console.log(ansis.white(`Oldest Session: ${ansis.gray(stats.oldestSession.toLocaleString())}`));
+      }
+      if (stats.newestSession) {
+        console.log(ansis.white(`Newest Session: ${ansis.gray(stats.newestSession.toLocaleString())}`));
+      }
+      if (stats.mostRecentlyUsed) {
+        console.log(ansis.white(`Most Recently Used: ${ansis.gray(stats.mostRecentlyUsed.toLocaleString())}`));
+      }
+    }
   } catch (error) {
     console.error(ansis.red("Failed to get status:"), error);
   }
 }
+async function createSessionCommand(options) {
+  try {
+    const sessionManager = getSessionManager();
+    let name = options.name;
+    let provider = options.provider;
+    let apiKey = options.apiKey;
+    if (!name) {
+      const { sessionName } = await inquirer.prompt({
+        type: "input",
+        name: "sessionName",
+        message: "Session name (optional):"
+      });
+      name = sessionName || void 0;
+    }
+    if (!provider) {
+      const { providerChoice } = await inquirer.prompt({
+        type: "list",
+        name: "providerChoice",
+        message: "Select API provider:",
+        choices: [
+          { name: "Anthropic (Claude)", value: "anthropic" },
+          { name: "OpenAI", value: "openai" },
+          { name: "Azure OpenAI", value: "azure" },
+          { name: "Custom", value: "custom" },
+          { name: "Skip (use default)", value: "" }
+        ]
+      });
+      provider = providerChoice || void 0;
+    }
+    if (provider && !apiKey) {
+      const { key } = await inquirer.prompt({
+        type: "password",
+        name: "key",
+        message: `Enter API key for ${provider} (optional):`,
+        mask: "*"
+      });
+      apiKey = key || void 0;
+    }
+    const session = await sessionManager.createSession(name, provider, apiKey, {
+      codeType: options.codeType
+    });
+    console.log(ansis.green(`
+\u2714 Session created successfully!`));
+    console.log(ansis.white(`  ID: ${ansis.cyan(session.id)}`));
+    if (session.name) {
+      console.log(ansis.white(`  Name: ${ansis.cyan(session.name)}`));
+    }
+    if (session.provider) {
+      console.log(ansis.white(`  Provider: ${ansis.cyan(session.provider)}`));
+    }
+    console.log(ansis.gray(`
+Use ${ansis.cyan(`ccjk --resume ${session.name || session.id}`)} to resume this session`));
+  } catch (error) {
+    console.error(ansis.red("Failed to create session:"), error);
+  }
+}
+async function renameSessionCommand(sessionId, options) {
+  try {
+    const sessionManager = getSessionManager();
+    if (!sessionId) {
+      console.log(ansis.red("Please provide a session ID or name"));
+      return;
+    }
+    let newName = options.name;
+    if (!newName) {
+      const { name } = await inquirer.prompt({
+        type: "input",
+        name: "name",
+        message: "Enter new session name:",
+        validate: (input) => input.trim().length > 0 || "Name cannot be empty"
+      });
+      newName = name;
+    }
+    const success = await sessionManager.renameSession(sessionId, newName);
+    if (success) {
+      console.log(ansis.green(`\u2714 Session renamed to: ${ansis.cyan(newName)}`));
+    } else {
+      console.log(ansis.red(`Session not found: ${sessionId}`));
+    }
+  } catch (error) {
+    console.error(ansis.red("Failed to rename session:"), error);
+  }
+}
+async function deleteSessionCommand(sessionId, options) {
+  try {
+    const sessionManager = getSessionManager();
+    if (!sessionId) {
+      console.log(ansis.red("Please provide a session ID or name"));
+      return;
+    }
+    const session = await sessionManager.loadSession(sessionId);
+    if (!session) {
+      console.log(ansis.red(`Session not found: ${sessionId}`));
+      return;
+    }
+    if (!options.force) {
+      console.log(ansis.yellow("\n\u26A0\uFE0F  You are about to delete:"));
+      console.log(ansis.white(`  ID: ${ansis.cyan(session.id)}`));
+      if (session.name) {
+        console.log(ansis.white(`  Name: ${ansis.cyan(session.name)}`));
+      }
+      console.log(ansis.white(`  Created: ${ansis.gray(session.createdAt.toLocaleString())}`));
+      console.log(ansis.white(`  History entries: ${ansis.gray(String(session.history.length))}`));
+      const { confirm } = await inquirer.prompt({
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to delete this session?",
+        default: false
+      });
+      if (!confirm) {
+        console.log(ansis.yellow("Deletion cancelled"));
+        return;
+      }
+    }
+    const success = await sessionManager.deleteSession(sessionId);
+    if (success) {
+      console.log(ansis.green(`\u2714 Session deleted: ${sessionId}`));
+    } else {
+      console.log(ansis.red(`Failed to delete session: ${sessionId}`));
+    }
+  } catch (error) {
+    console.error(ansis.red("Failed to delete session:"), error);
+  }
+}
 
-export { cleanupSession, exportSession, listSessions, restoreSession, saveSession, sessionStatus };
+export { cleanupSession, createSessionCommand, deleteSessionCommand, exportSession, listSessions, renameSessionCommand, restoreSession, saveSession, sessionStatus };