@sooink/ai-session-tidy 0.1.1

package/dist/index.js

@@ -0,0 +1,1917 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/scan.ts
+import { Command } from "commander";
+import Table from "cli-table3";
+import ora from "ora";
+import chalk2 from "chalk";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info(message) {
+    console.log(chalk.blue("\u2139"), message);
+  },
+  warn(message) {
+    console.log(chalk.yellow("\u26A0"), message);
+  },
+  error(message) {
+    console.log(chalk.red("\u2716"), message);
+  },
+  success(message) {
+    console.log(chalk.green("\u2714"), message);
+  },
+  debug(message) {
+    if (process.env["DEBUG"]) {
+      console.log(chalk.gray("\u{1F41B}"), message);
+    }
+  }
+};
+
+// src/utils/size.ts
+import { readdir, stat } from "fs/promises";
+import { join } from "path";
+var UNITS = ["B", "KB", "MB", "GB", "TB"];
+function formatSize(bytes) {
+  if (bytes <= 0) return "0 B";
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < UNITS.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  if (unitIndex === 0) {
+    return `${Math.floor(size)} ${UNITS[unitIndex]}`;
+  }
+  return `${size.toFixed(1)} ${UNITS[unitIndex]}`;
+}
+async function getDirectorySize(dirPath) {
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    let totalSize = 0;
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        totalSize += await getDirectorySize(fullPath);
+      } else if (entry.isFile()) {
+        const fileStat = await stat(fullPath);
+        totalSize += fileStat.size;
+      }
+    }
+    return totalSize;
+  } catch {
+    return 0;
+  }
+}
+
+// src/scanners/claude-code.ts
+import { readdir as readdir2, readFile, stat as stat2, access } from "fs/promises";
+import { join as join3 } from "path";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+function decodePath(encoded) {
+  if (encoded === "") return "";
+  if (!encoded.startsWith("-")) return encoded;
+  return encoded.replace(/-/g, "/");
+}
+function getConfigDir(appName) {
+  switch (process.platform) {
+    case "darwin":
+      return join2(homedir(), "Library/Application Support", appName);
+    case "win32":
+      return join2(process.env["APPDATA"] || "", appName);
+    default:
+      return join2(homedir(), ".config", appName);
+  }
+}
+function getClaudeProjectsDir() {
+  return join2(homedir(), ".claude", "projects");
+}
+function getClaudeConfigPath() {
+  return join2(homedir(), ".claude.json");
+}
+function getCursorWorkspaceDir() {
+  return join2(getConfigDir("Cursor"), "User", "workspaceStorage");
+}
+function getClaudeSessionEnvDir() {
+  return join2(homedir(), ".claude", "session-env");
+}
+function getClaudeTodosDir() {
+  return join2(homedir(), ".claude", "todos");
+}
+function getClaudeFileHistoryDir() {
+  return join2(homedir(), ".claude", "file-history");
+}
+function tildify(path) {
+  const home = homedir();
+  if (path.startsWith(home)) {
+    return path.replace(home, "~");
+  }
+  return path;
+}
+
+// src/scanners/claude-code.ts
+var ClaudeCodeScanner = class {
+  name = "claude-code";
+  projectsDir;
+  configPath;
+  sessionEnvDir;
+  todosDir;
+  fileHistoryDir;
+  constructor(projectsDirOrOptions) {
+    if (typeof projectsDirOrOptions === "string") {
+      this.projectsDir = projectsDirOrOptions;
+      this.configPath = null;
+      this.sessionEnvDir = null;
+      this.todosDir = null;
+      this.fileHistoryDir = null;
+    } else if (projectsDirOrOptions) {
+      this.projectsDir = projectsDirOrOptions.projectsDir ?? getClaudeProjectsDir();
+      this.configPath = projectsDirOrOptions.configPath === void 0 ? getClaudeConfigPath() : projectsDirOrOptions.configPath;
+      this.sessionEnvDir = projectsDirOrOptions.sessionEnvDir === void 0 ? getClaudeSessionEnvDir() : projectsDirOrOptions.sessionEnvDir;
+      this.todosDir = projectsDirOrOptions.todosDir === void 0 ? getClaudeTodosDir() : projectsDirOrOptions.todosDir;
+      this.fileHistoryDir = projectsDirOrOptions.fileHistoryDir === void 0 ? getClaudeFileHistoryDir() : projectsDirOrOptions.fileHistoryDir;
+    } else {
+      this.projectsDir = getClaudeProjectsDir();
+      this.configPath = getClaudeConfigPath();
+      this.sessionEnvDir = getClaudeSessionEnvDir();
+      this.todosDir = getClaudeTodosDir();
+      this.fileHistoryDir = getClaudeFileHistoryDir();
+    }
+  }
+  async isAvailable() {
+    try {
+      await access(this.projectsDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async scan() {
+    const startTime = performance.now();
+    const sessions = [];
+    if (await this.isAvailable()) {
+      const entries = await readdir2(this.projectsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const sessionPath = join3(this.projectsDir, entry.name);
+        let projectPath = await this.extractProjectPath(sessionPath);
+        if (!projectPath) {
+          projectPath = decodePath(entry.name);
+        }
+        const projectExists = await this.pathExists(projectPath);
+        if (projectExists) continue;
+        const size = await getDirectorySize(sessionPath);
+        if (size === 0) continue;
+        const lastModified = await this.getLastModified(sessionPath);
+        sessions.push({
+          toolName: this.name,
+          sessionPath,
+          projectPath,
+          size,
+          lastModified,
+          type: "session"
+        });
+      }
+    }
+    const configSessions = await this.scanConfigFile();
+    sessions.push(...configSessions);
+    const sessionEnvSessions = await this.scanSessionEnvDir();
+    sessions.push(...sessionEnvSessions);
+    const validSessionIds = await this.collectValidSessionIds();
+    const todosSessions = await this.scanTodosDir(validSessionIds);
+    sessions.push(...todosSessions);
+    const fileHistorySessions = await this.scanFileHistoryDir(validSessionIds);
+    sessions.push(...fileHistorySessions);
+    const totalSize = sessions.reduce((sum, s) => sum + s.size, 0);
+    return {
+      toolName: this.name,
+      sessions,
+      totalSize,
+      scanDuration: performance.now() - startTime
+    };
+  }
+  /**
+   * Detect orphaned projects from ~/.claude.json projects entries
+   */
+  async scanConfigFile() {
+    if (!this.configPath) {
+      return [];
+    }
+    const configPath = this.configPath;
+    const orphanedConfigs = [];
+    try {
+      const content = await readFile(configPath, "utf-8");
+      const config = JSON.parse(content);
+      const configStat = await stat2(configPath);
+      if (!config.projects || typeof config.projects !== "object") {
+        return [];
+      }
+      for (const [projectPath, projectData] of Object.entries(config.projects)) {
+        const projectExists = await this.pathExists(projectPath);
+        if (!projectExists) {
+          orphanedConfigs.push({
+            toolName: this.name,
+            sessionPath: configPath,
+            projectPath,
+            size: 0,
+            // config entries have negligible size
+            lastModified: configStat.mtime,
+            type: "config",
+            configStats: {
+              lastCost: projectData.lastCost,
+              lastTotalInputTokens: projectData.lastTotalInputTokens,
+              lastTotalOutputTokens: projectData.lastTotalOutputTokens
+            }
+          });
+        }
+      }
+    } catch {
+    }
+    return orphanedConfigs;
+  }
+  /**
+   * Detect empty session environment folders from ~/.claude/session-env
+   */
+  async scanSessionEnvDir() {
+    if (!this.sessionEnvDir) {
+      return [];
+    }
+    const orphanedEnvs = [];
+    try {
+      await access(this.sessionEnvDir);
+      const entries = await readdir2(this.sessionEnvDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const envPath = join3(this.sessionEnvDir, entry.name);
+        const files = await readdir2(envPath);
+        if (files.length === 0) {
+          const envStat = await stat2(envPath);
+          orphanedEnvs.push({
+            toolName: this.name,
+            sessionPath: envPath,
+            projectPath: entry.name,
+            // UUID
+            size: 0,
+            lastModified: envStat.mtime,
+            type: "session-env"
+          });
+        }
+      }
+    } catch {
+    }
+    return orphanedEnvs;
+  }
+  /**
+   * Collect valid session UUIDs from all projects
+   */
+  async collectValidSessionIds() {
+    const sessionIds = /* @__PURE__ */ new Set();
+    try {
+      const projectDirs = await readdir2(this.projectsDir, { withFileTypes: true });
+      for (const projectDir of projectDirs) {
+        if (!projectDir.isDirectory()) continue;
+        const projectPath = join3(this.projectsDir, projectDir.name);
+        const files = await readdir2(projectPath);
+        for (const file of files) {
+          if (file.endsWith(".jsonl")) {
+            const sessionId = file.replace(".jsonl", "");
+            sessionIds.add(sessionId);
+          }
+        }
+      }
+    } catch {
+    }
+    return sessionIds;
+  }
+  /**
+   * Detect orphaned todo files from ~/.claude/todos
+   * Filename pattern: {session-uuid}-agent-{agent-uuid}.json
+   */
+  async scanTodosDir(validSessionIds) {
+    if (!this.todosDir) {
+      return [];
+    }
+    const orphanedTodos = [];
+    try {
+      await access(this.todosDir);
+      const entries = await readdir2(this.todosDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+        const sessionId = entry.name.split("-agent-")[0];
+        if (!sessionId) continue;
+        if (!validSessionIds.has(sessionId)) {
+          const todoPath = join3(this.todosDir, entry.name);
+          const todoStat = await stat2(todoPath);
+          orphanedTodos.push({
+            toolName: this.name,
+            sessionPath: todoPath,
+            projectPath: sessionId,
+            // Session UUID
+            size: todoStat.size,
+            lastModified: todoStat.mtime,
+            type: "todos"
+          });
+        }
+      }
+    } catch {
+    }
+    return orphanedTodos;
+  }
+  /**
+   * Detect orphaned folders from ~/.claude/file-history
+   * Folder name is the session UUID
+   */
+  async scanFileHistoryDir(validSessionIds) {
+    if (!this.fileHistoryDir) {
+      return [];
+    }
+    const orphanedHistories = [];
+    try {
+      await access(this.fileHistoryDir);
+      const entries = await readdir2(this.fileHistoryDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const sessionId = entry.name;
+        if (!validSessionIds.has(sessionId)) {
+          const historyPath = join3(this.fileHistoryDir, entry.name);
+          const size = await getDirectorySize(historyPath);
+          const historyStat = await stat2(historyPath);
+          orphanedHistories.push({
+            toolName: this.name,
+            sessionPath: historyPath,
+            projectPath: sessionId,
+            // Session UUID
+            size,
+            lastModified: historyStat.mtime,
+            type: "file-history"
+          });
+        }
+      }
+    } catch {
+    }
+    return orphanedHistories;
+  }
+  /**
+   * Extract project path (cwd) from JSONL file
+   */
+  async extractProjectPath(sessionDir) {
+    try {
+      const files = await readdir2(sessionDir);
+      const jsonlFile = files.find((f) => f.endsWith(".jsonl"));
+      if (!jsonlFile) return null;
+      const jsonlPath = join3(sessionDir, jsonlFile);
+      const cwd = await this.findCwdInJsonl(jsonlPath);
+      return cwd;
+    } catch {
+      return null;
+    }
+  }
+  async findCwdInJsonl(jsonlPath) {
+    return new Promise((resolve3) => {
+      const stream = createReadStream(jsonlPath, { encoding: "utf-8" });
+      const rl = createInterface({ input: stream, crlfDelay: Infinity });
+      let found = false;
+      let lineCount = 0;
+      const maxLines = 10;
+      rl.on("line", (line) => {
+        if (found || lineCount >= maxLines) {
+          rl.close();
+          return;
+        }
+        lineCount++;
+        try {
+          const entry = JSON.parse(line);
+          if (entry.cwd) {
+            found = true;
+            rl.close();
+            stream.destroy();
+            resolve3(entry.cwd);
+          }
+        } catch {
+        }
+      });
+      rl.on("close", () => {
+        if (!found) resolve3(null);
+      });
+      rl.on("error", () => {
+        resolve3(null);
+      });
+    });
+  }
+  async pathExists(path) {
+    try {
+      await access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getLastModified(dirPath) {
+    try {
+      const entries = await readdir2(dirPath, { withFileTypes: true });
+      let latestTime = 0;
+      for (const entry of entries) {
+        const fullPath = join3(dirPath, entry.name);
+        const fileStat = await stat2(fullPath);
+        const mtime = fileStat.mtimeMs;
+        if (mtime > latestTime) {
+          latestTime = mtime;
+        }
+      }
+      return latestTime > 0 ? new Date(latestTime) : /* @__PURE__ */ new Date();
+    } catch {
+      return /* @__PURE__ */ new Date();
+    }
+  }
+};
+
+// src/scanners/cursor.ts
+import { readdir as readdir3, readFile as readFile2, stat as stat3, access as access2 } from "fs/promises";
+import { join as join4 } from "path";
+import { fileURLToPath } from "url";
+var CursorScanner = class {
+  name = "cursor";
+  workspaceDir;
+  constructor(workspaceDir) {
+    this.workspaceDir = workspaceDir ?? getCursorWorkspaceDir();
+  }
+  async isAvailable() {
+    try {
+      await access2(this.workspaceDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async scan() {
+    const startTime = performance.now();
+    const sessions = [];
+    if (!await this.isAvailable()) {
+      return {
+        toolName: this.name,
+        sessions: [],
+        totalSize: 0,
+        scanDuration: performance.now() - startTime
+      };
+    }
+    const entries = await readdir3(this.workspaceDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const sessionPath = join4(this.workspaceDir, entry.name);
+      const workspaceJsonPath = join4(sessionPath, "workspace.json");
+      const projectPath = await this.parseWorkspaceJson(workspaceJsonPath);
+      if (!projectPath) continue;
+      const projectExists = await this.pathExists(projectPath);
+      if (projectExists) continue;
+      const size = await getDirectorySize(sessionPath);
+      const lastModified = await this.getLastModified(sessionPath);
+      sessions.push({
+        toolName: this.name,
+        sessionPath,
+        projectPath,
+        size,
+        lastModified
+      });
+    }
+    const totalSize = sessions.reduce((sum, s) => sum + s.size, 0);
+    return {
+      toolName: this.name,
+      sessions,
+      totalSize,
+      scanDuration: performance.now() - startTime
+    };
+  }
+  async parseWorkspaceJson(workspaceJsonPath) {
+    try {
+      const content = await readFile2(workspaceJsonPath, "utf-8");
+      const data = JSON.parse(content);
+      if (!data.folder) return null;
+      if (data.folder.startsWith("file://")) {
+        return fileURLToPath(data.folder);
+      }
+      return data.folder;
+    } catch {
+      return null;
+    }
+  }
+  async pathExists(path) {
+    try {
+      await access2(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getLastModified(dirPath) {
+    try {
+      const entries = await readdir3(dirPath, { withFileTypes: true });
+      let latestTime = 0;
+      for (const entry of entries) {
+        const fullPath = join4(dirPath, entry.name);
+        const fileStat = await stat3(fullPath);
+        const mtime = fileStat.mtimeMs;
+        if (mtime > latestTime) {
+          latestTime = mtime;
+        }
+      }
+      return latestTime > 0 ? new Date(latestTime) : /* @__PURE__ */ new Date();
+    } catch {
+      return /* @__PURE__ */ new Date();
+    }
+  }
+};
+
+// src/scanners/index.ts
+function createAllScanners() {
+  return [new ClaudeCodeScanner(), new CursorScanner()];
+}
+async function getAvailableScanners(scanners) {
+  const results = await Promise.all(
+    scanners.map(async (scanner) => ({
+      scanner,
+      available: await scanner.isAvailable()
+    }))
+  );
+  return results.filter((r) => r.available).map((r) => r.scanner);
+}
+async function runAllScanners(scanners) {
+  return Promise.all(scanners.map((scanner) => scanner.scan()));
+}
+
+// src/commands/scan.ts
+function formatTokens(count) {
+  if (!count) return "0";
+  if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
+  if (count >= 1e3) return `${(count / 1e3).toFixed(0)}K`;
+  return count.toString();
+}
+var scanCommand = new Command("scan").description("Scan for orphaned session data from AI coding tools").option("-v, --verbose", "Enable verbose output").option("--json", "Output results as JSON").action(async (options) => {
+  const spinner = ora("Scanning for orphaned sessions...").start();
+  try {
+    const allScanners = createAllScanners();
+    const availableScanners = await getAvailableScanners(allScanners);
+    if (availableScanners.length === 0) {
+      spinner.warn("No AI coding tools detected on this system.");
+      return;
+    }
+    if (options.verbose) {
+      spinner.text = `Found ${availableScanners.length} tools: ${availableScanners.map((s) => s.name).join(", ")}`;
+    }
+    const results = await runAllScanners(availableScanners);
+    spinner.stop();
+    if (options.json) {
+      outputJson(results);
+    } else {
+      outputTable(results, options.verbose);
+    }
+  } catch (error) {
+    spinner.fail("Scan failed");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+});
+function outputJson(results) {
+  const allSessions = results.flatMap((r) => r.sessions);
+  const output = {
+    totalSessions: allSessions.length,
+    totalSize: results.reduce((sum, r) => sum + r.totalSize, 0),
+    results: results.map((r) => ({
+      tool: r.toolName,
+      sessionCount: r.sessions.length,
+      totalSize: r.totalSize,
+      scanDuration: r.scanDuration,
+      sessions: r.sessions
+    }))
+  };
+  console.log(JSON.stringify(output, null, 2));
+}
+function outputTable(results, verbose) {
+  const allSessions = results.flatMap((r) => r.sessions);
+  const folderSessions = allSessions.filter((s) => s.type === "session" || s.type === void 0);
+  const configEntries = allSessions.filter((s) => s.type === "config");
+  const sessionEnvEntries = allSessions.filter((s) => s.type === "session-env");
+  const todosEntries = allSessions.filter((s) => s.type === "todos");
+  const fileHistoryEntries = allSessions.filter((s) => s.type === "file-history");
+  const totalSize = results.reduce((sum, r) => sum + r.totalSize, 0);
+  if (allSessions.length === 0) {
+    logger.success("No orphaned sessions found.");
+    return;
+  }
+  console.log();
+  const parts = [];
+  if (folderSessions.length > 0) {
+    parts.push(`${folderSessions.length} session folder(s)`);
+  }
+  if (configEntries.length > 0) {
+    parts.push(`${configEntries.length} config entry(ies)`);
+  }
+  if (sessionEnvEntries.length > 0) {
+    parts.push(`${sessionEnvEntries.length} session-env folder(s)`);
+  }
+  if (todosEntries.length > 0) {
+    parts.push(`${todosEntries.length} todos file(s)`);
+  }
+  if (fileHistoryEntries.length > 0) {
+    parts.push(`${fileHistoryEntries.length} file-history folder(s)`);
+  }
+  logger.warn(`Found ${parts.join(" + ")} (${formatSize(totalSize)})`);
+  console.log();
+  const summaryTable = new Table({
+    head: [
+      chalk2.cyan("Tool"),
+      chalk2.cyan("Sessions"),
+      chalk2.cyan("Config"),
+      chalk2.cyan("Env"),
+      chalk2.cyan("Todos"),
+      chalk2.cyan("History"),
+      chalk2.cyan("Size"),
+      chalk2.cyan("Scan Time")
+    ],
+    style: { head: [] }
+  });
+  for (const result of results) {
+    if (result.sessions.length > 0) {
+      const folders = result.sessions.filter((s) => s.type === "session" || s.type === void 0).length;
+      const configs = result.sessions.filter((s) => s.type === "config").length;
+      const envs = result.sessions.filter((s) => s.type === "session-env").length;
+      const todos = result.sessions.filter((s) => s.type === "todos").length;
+      const histories = result.sessions.filter((s) => s.type === "file-history").length;
+      summaryTable.push([
+        result.toolName,
+        folders > 0 ? String(folders) : "-",
+        configs > 0 ? String(configs) : "-",
+        envs > 0 ? String(envs) : "-",
+        todos > 0 ? String(todos) : "-",
+        histories > 0 ? String(histories) : "-",
+        formatSize(result.totalSize),
+        `${result.scanDuration.toFixed(0)}ms`
+      ]);
+    }
+  }
+  console.log(summaryTable.toString());
+  if (verbose && allSessions.length > 0) {
+    if (folderSessions.length > 0) {
+      console.log();
+      console.log(chalk2.bold("Session Folders:"));
+      console.log();
+      for (const session of folderSessions) {
+        const projectName = session.projectPath.split("/").pop() || session.projectPath;
+        console.log(
+          `  ${chalk2.cyan(`[${session.toolName}]`)} ${chalk2.white(projectName)} ${chalk2.dim(`(${formatSize(session.size)})`)}`
+        );
+        console.log(`    ${chalk2.dim("\u2192")} ${session.projectPath}`);
+        console.log(`    ${chalk2.dim("Modified:")} ${session.lastModified.toLocaleDateString()}`);
+        console.log();
+      }
+    }
+    if (configEntries.length > 0) {
+      console.log();
+      console.log(chalk2.bold("Config Entries (~/.claude.json):"));
+      console.log();
+      for (const entry of configEntries) {
+        const projectName = entry.projectPath.split("/").pop() || entry.projectPath;
+        console.log(
+          `  ${chalk2.yellow("[config]")} ${chalk2.white(projectName)}`
+        );
+        console.log(`    ${chalk2.dim("\u2192")} ${entry.projectPath}`);
+        if (entry.configStats?.lastCost) {
+          const cost = `$${entry.configStats.lastCost.toFixed(2)}`;
+          const inTokens = formatTokens(entry.configStats.lastTotalInputTokens);
+          const outTokens = formatTokens(entry.configStats.lastTotalOutputTokens);
+          console.log(`    ${chalk2.dim(`Cost: ${cost} | Tokens: ${inTokens} in / ${outTokens} out`)}`);
+        }
+        console.log();
+      }
+    }
+  }
+  console.log();
+  console.log(
+    chalk2.dim('Run "ai-session-tidy clean" to remove orphaned sessions.')
+  );
+}
+
+// src/commands/clean.ts
+import { basename } from "path";
+import { Command as Command2 } from "commander";
+import ora2 from "ora";
+import chalk3 from "chalk";
+import inquirer from "inquirer";
+
+// src/core/cleaner.ts
+import { readFile as readFile3, writeFile, mkdir, copyFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/core/trash.ts
+import { rm, access as access3 } from "fs/promises";
+import trash from "trash";
+async function pathExists(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function moveToTrash(path) {
+  if (!await pathExists(path)) {
+    return false;
+  }
+  await trash(path);
+  return true;
+}
+async function permanentDelete(path) {
+  if (!await pathExists(path)) {
+    return false;
+  }
+  await rm(path, { recursive: true, force: true });
+  return true;
+}
+
+// src/core/cleaner.ts
+function getBackupDir() {
+  return join5(homedir2(), ".ai-session-tidy", "backups");
+}
+var Cleaner = class {
+  async clean(sessions, options) {
+    const result = {
+      deletedCount: 0,
+      deletedByType: {
+        session: 0,
+        sessionEnv: 0,
+        todos: 0,
+        fileHistory: 0
+      },
+      skippedCount: 0,
+      alreadyGoneCount: 0,
+      configEntriesRemoved: 0,
+      totalSizeDeleted: 0,
+      errors: []
+    };
+    const useTrash = options.useTrash ?? true;
+    const folderSessions = sessions.filter((s) => s.type !== "config");
+    const configEntries = sessions.filter((s) => s.type === "config");
+    for (const session of folderSessions) {
+      if (options.dryRun) {
+        result.skippedCount++;
+        continue;
+      }
+      try {
+        const deleted = useTrash ? await moveToTrash(session.sessionPath) : await permanentDelete(session.sessionPath);
+        if (deleted) {
+          result.deletedCount++;
+          result.totalSizeDeleted += session.size;
+          switch (session.type) {
+            case "session-env":
+              result.deletedByType.sessionEnv++;
+              break;
+            case "todos":
+              result.deletedByType.todos++;
+              break;
+            case "file-history":
+              result.deletedByType.fileHistory++;
+              break;
+            default:
+              result.deletedByType.session++;
+          }
+        } else {
+          result.alreadyGoneCount++;
+        }
+      } catch (error) {
+        result.errors.push({
+          sessionPath: session.sessionPath,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    if (configEntries.length > 0 && !options.dryRun) {
+      try {
+        const configResult = await this.cleanConfigEntries(configEntries);
+        result.configEntriesRemoved = configResult.removed;
+        result.backupPath = configResult.backupPath;
+      } catch (error) {
+        result.errors.push({
+          sessionPath: configEntries[0].sessionPath,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    } else if (options.dryRun) {
+      result.skippedCount += configEntries.length;
+    }
+    return result;
+  }
+  /**
+   * Remove orphaned project entries from ~/.claude.json
+   */
+  async cleanConfigEntries(entries) {
+    if (entries.length === 0) {
+      return { removed: 0, backupPath: "" };
+    }
+    const configPath = entries[0].sessionPath;
+    const projectPathsToRemove = new Set(entries.map((e) => e.projectPath));
+    const backupDir = getBackupDir();
+    if (!existsSync(backupDir)) {
+      await mkdir(backupDir, { recursive: true });
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = join5(backupDir, `claude.json.${timestamp}.bak`);
+    await copyFile(configPath, backupPath);
+    const content = await readFile3(configPath, "utf-8");
+    const config = JSON.parse(content);
+    if (!config.projects) {
+      return { removed: 0, backupPath };
+    }
+    let removedCount = 0;
+    for (const projectPath of projectPathsToRemove) {
+      if (projectPath in config.projects) {
+        delete config.projects[projectPath];
+        removedCount++;
+      }
+    }
+    if (removedCount > 0) {
+      await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    return { removed: removedCount, backupPath };
+  }
+};
+
+// src/commands/clean.ts
+function formatSessionChoice(session) {
+  const projectName = basename(session.projectPath);
+  const isConfig = session.type === "config";
+  const toolTag = isConfig ? chalk3.yellow("[config]") : chalk3.cyan(`[${session.toolName}]`);
+  const name = chalk3.white(projectName);
+  const size = isConfig ? "" : chalk3.dim(`(${formatSize(session.size)})`);
+  const path = chalk3.dim(`\u2192 ${session.projectPath}`);
+  return `${toolTag} ${name} ${size}
+    ${path}`;
+}
+var cleanCommand = new Command2("clean").description("Remove orphaned session data").option("-f, --force", "Skip confirmation prompt").option("-n, --dry-run", "Show what would be deleted without deleting").option("-i, --interactive", "Select sessions to delete interactively").option("--no-trash", "Permanently delete instead of moving to trash").option("-v, --verbose", "Enable verbose output").action(async (options) => {
+  const spinner = ora2("Scanning for orphaned sessions...").start();
+  try {
+    const allScanners = createAllScanners();
+    const availableScanners = await getAvailableScanners(allScanners);
+    if (availableScanners.length === 0) {
+      spinner.warn("No AI coding tools detected on this system.");
+      return;
+    }
+    const results = await runAllScanners(availableScanners);
+    const allSessions = results.flatMap((r) => r.sessions);
+    const totalSize = results.reduce((sum, r) => sum + r.totalSize, 0);
+    spinner.stop();
+    if (allSessions.length === 0) {
+      logger.success("No orphaned sessions found.");
+      return;
+    }
+    const folderSessions = allSessions.filter(
+      (s) => s.type === "session" || s.type === void 0
+    );
+    const configEntries = allSessions.filter((s) => s.type === "config");
+    const sessionEnvEntries = allSessions.filter(
+      (s) => s.type === "session-env"
+    );
+    const todosEntries = allSessions.filter((s) => s.type === "todos");
+    const fileHistoryEntries = allSessions.filter(
+      (s) => s.type === "file-history"
+    );
+    const autoCleanEntries = [
+      ...sessionEnvEntries,
+      ...todosEntries,
+      ...fileHistoryEntries
+    ];
+    const selectableSessions = allSessions.filter(
+      (s) => s.type !== "session-env" && s.type !== "todos" && s.type !== "file-history"
+    );
+    console.log();
+    const parts = [];
+    if (folderSessions.length > 0) {
+      parts.push(`${folderSessions.length} session folder(s)`);
+    }
+    if (configEntries.length > 0) {
+      parts.push(`${configEntries.length} config entry(ies)`);
+    }
+    if (sessionEnvEntries.length > 0) {
+      parts.push(`${sessionEnvEntries.length} session-env folder(s)`);
+    }
+    if (todosEntries.length > 0) {
+      parts.push(`${todosEntries.length} todos file(s)`);
+    }
+    if (fileHistoryEntries.length > 0) {
+      parts.push(`${fileHistoryEntries.length} file-history folder(s)`);
+    }
+    logger.warn(`Found ${parts.join(" + ")} (${formatSize(totalSize)})`);
+    if (options.verbose && !options.interactive) {
+      console.log();
+      for (const session of selectableSessions) {
+        console.log(
+          chalk3.dim(`  ${session.toolName}: ${session.projectPath}`)
+        );
+      }
+    }
+    let sessionsToClean = allSessions;
+    if (options.interactive) {
+      if (selectableSessions.length === 0) {
+        if (autoCleanEntries.length > 0) {
+          sessionsToClean = autoCleanEntries;
+          logger.info(
+            `Only ${autoCleanEntries.length} auto-cleanup target(s) found`
+          );
+        } else {
+          logger.info("No selectable sessions found.");
+          return;
+        }
+      } else {
+        console.log();
+        const { selected } = await inquirer.prompt([
+          {
+            type: "checkbox",
+            name: "selected",
+            message: "Select sessions to delete:",
+            choices: selectableSessions.map((session) => ({
+              name: formatSessionChoice(session),
+              value: session,
+              checked: false
+            })),
+            pageSize: 15,
+            loop: false
+          }
+        ]);
+        if (selected.length === 0) {
+          logger.info("No sessions selected. Cancelled.");
+          return;
+        }
+        sessionsToClean = [...selected, ...autoCleanEntries];
+        const selectedSize = selected.reduce((sum, s) => sum + s.size, 0);
+        console.log();
+        if (selected.length > 0) {
+          logger.info(
+            `Selected: ${selected.length} session(s) (${formatSize(selectedSize)})`
+          );
+        }
+        if (autoCleanEntries.length > 0) {
+          const autoSize = autoCleanEntries.reduce((sum, s) => sum + s.size, 0);
+          logger.info(
+            `+ ${autoCleanEntries.length} auto-cleanup target(s) (${formatSize(autoSize)})`
+          );
+        }
+      }
+    }
+    const cleanSize = sessionsToClean.reduce((sum, s) => sum + s.size, 0);
+    if (options.dryRun) {
+      console.log();
+      logger.info(
+        chalk3.yellow("Dry-run mode: No files will be deleted.")
+      );
+      console.log();
+      const dryRunFolders = sessionsToClean.filter(
+        (s) => s.type === "session" || s.type === void 0
+      );
+      const dryRunConfigs = sessionsToClean.filter((s) => s.type === "config");
+      const dryRunEnvs = sessionsToClean.filter(
+        (s) => s.type === "session-env"
+      );
+      const dryRunTodos = sessionsToClean.filter((s) => s.type === "todos");
+      const dryRunHistories = sessionsToClean.filter(
+        (s) => s.type === "file-history"
+      );
+      for (const session of dryRunFolders) {
+        console.log(
+          `  ${chalk3.red("Would delete:")} ${session.sessionPath} (${formatSize(session.size)})`
+        );
+      }
+      if (dryRunConfigs.length > 0) {
+        console.log();
+        console.log(
+          `  ${chalk3.yellow("Would remove from ~/.claude.json:")}`
+        );
+        for (const config of dryRunConfigs) {
+          console.log(`    - ${config.projectPath}`);
+        }
+      }
+      const autoCleanParts = [];
+      if (dryRunEnvs.length > 0) {
+        autoCleanParts.push(`${dryRunEnvs.length} session-env`);
+      }
+      if (dryRunTodos.length > 0) {
+        autoCleanParts.push(`${dryRunTodos.length} todos`);
+      }
+      if (dryRunHistories.length > 0) {
+        autoCleanParts.push(`${dryRunHistories.length} file-history`);
+      }
+      if (autoCleanParts.length > 0) {
+        const autoSize = dryRunEnvs.reduce((sum, s) => sum + s.size, 0) + dryRunTodos.reduce((sum, s) => sum + s.size, 0) + dryRunHistories.reduce((sum, s) => sum + s.size, 0);
+        console.log();
+        console.log(
+          `  ${chalk3.dim(`Would auto-delete: ${autoCleanParts.join(" + ")} (${formatSize(autoSize)})`)}`
+        );
+      }
+      return;
+    }
+    if (!options.force) {
+      console.log();
+      const action = options.noTrash ? "permanently delete" : "move to trash";
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirmed",
+          message: `${action} ${sessionsToClean.length} session(s) (${formatSize(cleanSize)})?`,
+          default: false
+        }
+      ]);
+      if (!confirmed) {
+        logger.info("Cancelled.");
+        return;
+      }
+    }
+    const cleanSpinner = ora2("Cleaning orphaned sessions...").start();
+    const cleaner = new Cleaner();
+    const cleanResult = await cleaner.clean(sessionsToClean, {
+      dryRun: false,
+      useTrash: !options.noTrash
+    });
+    cleanSpinner.stop();
+    console.log();
+    if (cleanResult.deletedCount > 0) {
+      const action = options.noTrash ? "Deleted" : "Moved to trash";
+      const parts2 = [];
+      const { deletedByType } = cleanResult;
+      if (deletedByType.session > 0) {
+        parts2.push(`${deletedByType.session} session`);
+      }
+      if (deletedByType.sessionEnv > 0) {
+        parts2.push(`${deletedByType.sessionEnv} session-env`);
+      }
+      if (deletedByType.todos > 0) {
+        parts2.push(`${deletedByType.todos} todos`);
+      }
+      if (deletedByType.fileHistory > 0) {
+        parts2.push(`${deletedByType.fileHistory} file-history`);
+      }
+      const summary = parts2.length > 0 ? parts2.join(" + ") : `${cleanResult.deletedCount} item(s)`;
+      logger.success(
+        `${action}: ${summary} (${formatSize(cleanResult.totalSizeDeleted)})`
+      );
+    }
+    if (cleanResult.alreadyGoneCount > 0 && options.verbose) {
+      logger.info(
+        `Skipped ${cleanResult.alreadyGoneCount} already-deleted item(s)`
+      );
+    }
+    if (cleanResult.configEntriesRemoved > 0) {
+      logger.success(
+        `Removed ${cleanResult.configEntriesRemoved} config entry(ies) from ~/.claude.json`
+      );
+      if (cleanResult.backupPath) {
+        logger.info(`Backup saved to: ${tildify(cleanResult.backupPath)}`);
+      }
+    }
+    if (cleanResult.errors.length > 0) {
+      logger.error(`Failed to delete ${cleanResult.errors.length} item(s)`);
+      if (options.verbose) {
+        for (const err of cleanResult.errors) {
+          console.log(chalk3.red(`  ${err.sessionPath}: ${err.error.message}`));
+        }
+      }
+    }
+  } catch (error) {
+    spinner.fail("Clean failed");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/watch.ts
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join8, resolve as resolve2 } from "path";
+
+// src/utils/config.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join6, resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var CONFIG_VERSION = "0.1";
+function getAppVersion() {
+  const __dirname = dirname2(fileURLToPath2(import.meta.url));
+  const paths = [
+    join6(__dirname, "..", "..", "package.json"),
+    // from src/utils/
+    join6(__dirname, "..", "package.json")
+    // from dist/
+  ];
+  for (const packagePath of paths) {
+    try {
+      if (existsSync2(packagePath)) {
+        const content = readFileSync(packagePath, "utf-8");
+        const pkg = JSON.parse(content);
+        return pkg.version;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return "unknown";
+}
+function getConfigPath() {
+  return join6(homedir3(), ".config", "ai-session-tidy", "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync2(configPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  const configDir = dirname2(configPath);
+  if (!existsSync2(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  const configWithVersion = {
+    version: getAppVersion(),
+    configVersion: CONFIG_VERSION,
+    ...config
+  };
+  writeFileSync(configPath, JSON.stringify(configWithVersion, null, 2), "utf-8");
+}
+function getWatchPaths() {
+  const config = loadConfig();
+  return config.watchPaths;
+}
+function setWatchPaths(paths) {
+  const config = loadConfig();
+  config.watchPaths = paths;
+  saveConfig(config);
+}
+function addWatchPath(path) {
+  const config = loadConfig();
+  const resolved = resolve(path.replace(/^~/, homedir3()));
+  const paths = config.watchPaths ?? [];
+  if (!paths.includes(resolved)) {
+    paths.push(resolved);
+    config.watchPaths = paths;
+    saveConfig(config);
+  }
+}
+function removeWatchPath(path) {
+  const config = loadConfig();
+  const resolved = resolve(path.replace(/^~/, homedir3()));
+  const paths = config.watchPaths ?? [];
+  const index = paths.indexOf(resolved);
+  if (index === -1) return false;
+  paths.splice(index, 1);
+  config.watchPaths = paths;
+  saveConfig(config);
+  return true;
+}
+function getWatchDelay() {
+  const config = loadConfig();
+  return config.watchDelay;
+}
+function setWatchDelay(minutes) {
+  const config = loadConfig();
+  config.watchDelay = minutes;
+  saveConfig(config);
+}
+function getWatchDepth() {
+  const config = loadConfig();
+  return config.watchDepth;
+}
+function setWatchDepth(depth) {
+  const config = loadConfig();
+  config.watchDepth = Math.min(depth, 5);
+  saveConfig(config);
+}
+function resetConfig() {
+  saveConfig({});
+}
+
+// src/core/watcher.ts
+import { watch } from "chokidar";
+import { access as access4 } from "fs/promises";
+var Watcher = class {
+  options;
+  debounceMs;
+  watcher = null;
+  /** Per-path delay timers */
+  pendingDeletes = /* @__PURE__ */ new Map();
+  /** Events waiting for debounce */
+  batchedEvents = [];
+  /** Debounce timer */
+  debounceTimer = null;
+  constructor(options) {
+    this.options = options;
+    this.debounceMs = options.debounceMs ?? 1e4;
+  }
+  start() {
+    if (this.watcher) return;
+    this.watcher = watch(this.options.watchPaths, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: this.options.depth ?? 3
+    });
+    this.watcher.on("unlinkDir", (path) => {
+      this.handleDelete(path);
+    });
+    this.watcher.on("addDir", (path) => {
+      this.handleRecovery(path);
+    });
+  }
+  stop() {
+    if (!this.watcher) return;
+    this.watcher.close();
+    this.watcher = null;
+    for (const timeout of this.pendingDeletes.values()) {
+      clearTimeout(timeout);
+    }
+    this.pendingDeletes.clear();
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    this.batchedEvents = [];
+  }
+  isWatching() {
+    return this.watcher !== null;
+  }
+  /**
+   * Handle folder deletion event
+   *
+   * Stage 1: Set per-path delay timer
+   * - Don't process immediately to allow recovery
+   * - Add to batch if still deleted after delay
+   */
+  handleDelete(path) {
+    if (this.pendingDeletes.has(path)) return;
+    const timeout = setTimeout(async () => {
+      const stillDeleted = !await this.pathExists(path);
+      if (stillDeleted) {
+        this.addToBatch({
+          path,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      this.pendingDeletes.delete(path);
+    }, this.options.delayMs);
+    this.pendingDeletes.set(path, timeout);
+  }
+  /**
+   * Add event to batch and reset debounce timer
+   *
+   * Stage 2: Debounce
+   * - Reset timer on each new event
+   * - Execute batch when no new events for debounce period
+   * - This combines multiple subfolder deletions into single cleanup
+   */
+  addToBatch(event) {
+    this.batchedEvents.push(event);
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.flushBatch();
+    }, this.debounceMs);
+  }
+  /**
+   * Deliver batched events to callback
+   * - Scan/cleanup runs only once
+   */
+  flushBatch() {
+    if (this.batchedEvents.length === 0) return;
+    const events = [...this.batchedEvents];
+    this.batchedEvents = [];
+    this.debounceTimer = null;
+    this.options.onDelete(events);
+  }
+  handleRecovery(path) {
+    const timeout = this.pendingDeletes.get(path);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.pendingDeletes.delete(path);
+    }
+  }
+  async pathExists(path) {
+    try {
+      await access4(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/service.ts
+import { homedir as homedir4 } from "os";
+import { join as join7, dirname as dirname3 } from "path";
+import { readFile as readFile4, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { execSync } from "child_process";
+var SERVICE_LABEL = "sooink.ai-session-tidy.watcher";
+var PLIST_FILENAME = `${SERVICE_LABEL}.plist`;
+function getPlistPath() {
+  return join7(homedir4(), "Library", "LaunchAgents", PLIST_FILENAME);
+}
+function getNodePath() {
+  return process.execPath;
+}
+function getScriptPath() {
+  const scriptPath = process.argv[1];
+  if (scriptPath && existsSync3(scriptPath)) {
+    return scriptPath;
+  }
+  throw new Error("Could not determine script path");
+}
+function generatePlist(options) {
+  const allArgs = [options.nodePath, options.scriptPath, ...options.args];
+  const argsXml = allArgs.map((arg) => `    <string>${arg}</string>`).join("\n");
+  const home = homedir4();
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${options.label}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${home}</string>
+  </dict>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join7(home, ".ai-session-tidy", "watcher.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join7(home, ".ai-session-tidy", "watcher.error.log")}</string>
+</dict>
+</plist>`;
+}
+var ServiceManager = class {
+  plistPath;
+  constructor() {
+    this.plistPath = getPlistPath();
+  }
+  isSupported() {
+    return process.platform === "darwin";
+  }
+  async install() {
+    if (!this.isSupported()) {
+      throw new Error("Service management is only supported on macOS");
+    }
+    const launchAgentsDir = dirname3(this.plistPath);
+    if (!existsSync3(launchAgentsDir)) {
+      await mkdir2(launchAgentsDir, { recursive: true });
+    }
+    const logDir = join7(homedir4(), ".ai-session-tidy");
+    if (!existsSync3(logDir)) {
+      await mkdir2(logDir, { recursive: true });
+    }
+    const stdoutPath = join7(logDir, "watcher.log");
+    const stderrPath = join7(logDir, "watcher.error.log");
+    await writeFile2(stdoutPath, "", "utf-8");
+    await writeFile2(stderrPath, "", "utf-8");
+    const plistContent = generatePlist({
+      label: SERVICE_LABEL,
+      nodePath: getNodePath(),
+      scriptPath: getScriptPath(),
+      args: ["watch", "run"]
+    });
+    await writeFile2(this.plistPath, plistContent, "utf-8");
+  }
+  async uninstall() {
+    if (existsSync3(this.plistPath)) {
+      await unlink(this.plistPath);
+    }
+  }
+  async start() {
+    if (!this.isSupported()) {
+      throw new Error("Service management is only supported on macOS");
+    }
+    if (!existsSync3(this.plistPath)) {
+      throw new Error('Service not installed. Run "watch start" to install and start.');
+    }
+    try {
+      execSync(`launchctl load "${this.plistPath}"`, { stdio: "pipe" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes("already loaded")) {
+        throw error;
+      }
+    }
+  }
+  async stop() {
+    if (!this.isSupported()) {
+      throw new Error("Service management is only supported on macOS");
+    }
+    if (!existsSync3(this.plistPath)) {
+      return;
+    }
+    try {
+      execSync(`launchctl unload "${this.plistPath}"`, { stdio: "pipe" });
+    } catch {
+    }
+  }
+  async status() {
+    const info = {
+      status: "not_installed",
+      label: SERVICE_LABEL,
+      plistPath: this.plistPath
+    };
+    if (!this.isSupported()) {
+      return info;
+    }
+    if (!existsSync3(this.plistPath)) {
+      return info;
+    }
+    try {
+      const output = execSync("launchctl list", { encoding: "utf-8" });
+      const lines = output.split("\n");
+      for (const line of lines) {
+        if (line.includes(SERVICE_LABEL)) {
+          const parts = line.split(/\s+/);
+          const pid = parseInt(parts[0] ?? "", 10);
+          if (!isNaN(pid) && pid > 0) {
+            info.status = "running";
+            info.pid = pid;
+          } else {
+            info.status = "stopped";
+          }
+          return info;
+        }
+      }
+      info.status = "stopped";
+      return info;
+    } catch {
+      info.status = "stopped";
+      return info;
+    }
+  }
+  async getLogs(lines = 50) {
+    const logDir = join7(homedir4(), ".ai-session-tidy");
+    const stdoutPath = join7(logDir, "watcher.log");
+    const stderrPath = join7(logDir, "watcher.error.log");
+    let stdout = "";
+    let stderr = "";
+    try {
+      if (existsSync3(stdoutPath)) {
+        const content = await readFile4(stdoutPath, "utf-8");
+        const logLines = content.split("\n");
+        stdout = logLines.slice(-lines).join("\n");
+      }
+    } catch {
+    }
+    try {
+      if (existsSync3(stderrPath)) {
+        const content = await readFile4(stderrPath, "utf-8");
+        const logLines = content.split("\n");
+        stderr = logLines.slice(-lines).join("\n");
+      }
+    } catch {
+    }
+    return { stdout, stderr };
+  }
+};
+var serviceManager = new ServiceManager();
+
+// src/commands/watch.ts
+var DEFAULT_DELAY_MINUTES = 5;
+var MAX_DELAY_MINUTES = 10;
+var watchCommand = new Command3("watch").description("Watch for project deletions and auto-clean orphaned sessions");
+var runCommand = new Command3("run").description("Run watcher in foreground (default)").option(
+  "-p, --path <path>",
+  "Path to watch (can be used multiple times, saves to config)",
+  (value, previous) => previous.concat([value]),
+  []
+).option("--no-save", "Do not save paths to config").option(
+  "-d, --delay <minutes>",
+  `Delay before cleanup (default: ${DEFAULT_DELAY_MINUTES}, max: ${MAX_DELAY_MINUTES} minutes)`
+).option("--no-trash", "Permanently delete instead of moving to trash").option("-v, --verbose", "Enable verbose output").action(runWatcher);
+var startCommand = new Command3("start").description("Start watcher as OS service (background + auto-start at login)").action(async () => {
+  const supported = serviceManager.isSupported();
+  if (!supported) {
+    logger.error("Service management is only supported on macOS.");
+    logger.info('Use "watch run" to run the watcher in foreground.');
+    return;
+  }
+  try {
+    const currentStatus = await serviceManager.status();
+    if (currentStatus.status === "running") {
+      logger.info("Watcher service is already running.");
+      return;
+    }
+    logger.info("Installing watcher service...");
+    await serviceManager.install();
+    logger.info("Starting watcher service...");
+    await serviceManager.start();
+    const status = await serviceManager.status();
+    if (status.status === "running") {
+      logger.success(`Watcher service started (PID: ${status.pid})`);
+      logger.info("The watcher will automatically start at login.");
+      logger.info(`Logs: ~/.ai-session-tidy/watcher.log`);
+    } else {
+      logger.warn("Service installed but may not be running yet.");
+      logger.info("Check status with: ai-session-tidy watch status");
+    }
+  } catch (error) {
+    logger.error(`Failed to start service: ${error instanceof Error ? error.message : String(error)}`);
+  }
+});
+var stopCommand = new Command3("stop").description("Stop watcher service and disable auto-start").action(async () => {
+  const supported = serviceManager.isSupported();
+  if (!supported) {
+    logger.error("Service management is only supported on macOS.");
+    return;
+  }
+  try {
+    const currentStatus = await serviceManager.status();
+    if (currentStatus.status === "not_installed") {
+      logger.info("Watcher service is not installed.");
+      return;
+    }
+    logger.info("Stopping watcher service...");
+    await serviceManager.stop();
+    logger.info("Removing service configuration...");
+    await serviceManager.uninstall();
+    logger.success("Watcher service stopped and removed.");
+  } catch (error) {
+    logger.error(`Failed to stop service: ${error instanceof Error ? error.message : String(error)}`);
+  }
+});
+var statusCommand = new Command3("status").description("Show watcher service status").option("-l, --logs [lines]", "Show recent logs", "20").action(async (options) => {
+  const supported = serviceManager.isSupported();
+  if (!supported) {
+    logger.error("Service management is only supported on macOS.");
+    return;
+  }
+  try {
+    const status = await serviceManager.status();
+    console.log();
+    console.log(chalk4.bold("Watcher Service Status"));
+    console.log("\u2500".repeat(40));
+    console.log(`Label:  ${status.label}`);
+    console.log(`Status: ${formatStatus(status.status)}`);
+    if (status.pid) {
+      console.log(`PID:    ${status.pid}`);
+    }
+    console.log(`Plist:  ${status.plistPath}`);
+    console.log();
+    if (options.logs) {
+      const lines = parseInt(options.logs, 10) || 20;
+      const logs = await serviceManager.getLogs(lines);
+      if (logs.stdout) {
+        console.log(chalk4.bold("Recent Logs:"));
+        console.log("\u2500".repeat(40));
+        console.log(logs.stdout);
+        console.log();
+      }
+      if (logs.stderr) {
+        console.log(chalk4.bold.red("Error Logs:"));
+        console.log("\u2500".repeat(40));
+        console.log(logs.stderr);
+        console.log();
+      }
+    }
+  } catch (error) {
+    logger.error(`Failed to get status: ${error instanceof Error ? error.message : String(error)}`);
+  }
+});
+function formatStatus(status) {
+  switch (status) {
+    case "running":
+      return chalk4.green("running");
+    case "stopped":
+      return chalk4.yellow("stopped");
+    case "not_installed":
+      return chalk4.dim("not installed");
+    default:
+      return status;
+  }
+}
+watchCommand.addCommand(runCommand, { isDefault: true });
+watchCommand.addCommand(startCommand);
+watchCommand.addCommand(stopCommand);
+watchCommand.addCommand(statusCommand);
+async function runWatcher(options) {
+  const configDelay = getWatchDelay();
+  let delayMinutes = options.delay ? parseInt(options.delay, 10) : configDelay ?? DEFAULT_DELAY_MINUTES;
+  if (delayMinutes > MAX_DELAY_MINUTES) {
+    logger.warn(`Maximum delay is ${MAX_DELAY_MINUTES} minutes. Using ${MAX_DELAY_MINUTES}.`);
+    delayMinutes = MAX_DELAY_MINUTES;
+  }
+  const delayMs = delayMinutes * 60 * 1e3;
+  let watchPaths;
+  if (options.path && options.path.length > 0) {
+    watchPaths = options.path.map((p) => resolve2(p.replace(/^~/, homedir5())));
+    if (!options.noSave) {
+      setWatchPaths(watchPaths);
+      logger.info(`Saved watch paths to config.`);
+    }
+  } else {
+    const configPaths = getWatchPaths();
+    if (configPaths && configPaths.length > 0) {
+      watchPaths = configPaths;
+      logger.info(`Using saved watch paths from config.`);
+    } else {
+      watchPaths = getDefaultWatchPaths();
+      logger.info(`Using default watch paths.`);
+    }
+  }
+  const validPaths = watchPaths.filter((p) => existsSync4(p));
+  if (validPaths.length === 0) {
+    logger.error("No valid watch paths found. Use -p to specify paths.");
+    return;
+  }
+  if (validPaths.length < watchPaths.length) {
+    const invalidPaths = watchPaths.filter((p) => !existsSync4(p));
+    logger.warn(`Skipping non-existent paths: ${invalidPaths.join(", ")}`);
+  }
+  const allScanners = createAllScanners();
+  const availableScanners = await getAvailableScanners(allScanners);
+  if (availableScanners.length === 0) {
+    logger.warn("No AI coding tools detected on this system.");
+    return;
+  }
+  const depth = getWatchDepth() ?? 3;
+  logger.info(
+    `Watching for project deletions (${availableScanners.map((s) => s.name).join(", ")})`
+  );
+  logger.info(`Watch paths: ${validPaths.join(", ")}`);
+  logger.info(`Cleanup delay: ${String(delayMinutes)} minute(s)`);
+  logger.info(`Watch depth: ${String(depth)}`);
+  if (process.stdout.isTTY) {
+    logger.info(chalk4.dim("Press Ctrl+C to stop watching."));
+  }
+  console.log();
+  const cleaner = new Cleaner();
+  const watcher = new Watcher({
+    watchPaths: validPaths,
+    delayMs,
+    depth,
+    onDelete: async (events) => {
+      if (events.length === 1) {
+        logger.info(`Detected deletion: ${events[0].path}`);
+      } else {
+        logger.info(`Detected ${events.length} deletions (debounced)`);
+        if (options.verbose) {
+          for (const event of events) {
+            logger.debug(`  - ${event.path}`);
+          }
+        }
+      }
+      const results = await runAllScanners(availableScanners);
+      const allSessions = results.flatMap((r) => r.sessions);
+      if (allSessions.length === 0) {
+        if (options.verbose) {
+          logger.debug("No orphaned sessions found after deletion.");
+        }
+        return;
+      }
+      const cleanResult = await cleaner.clean(allSessions, {
+        dryRun: false,
+        useTrash: !options.noTrash
+      });
+      if (cleanResult.deletedCount > 0) {
+        const action = options.noTrash ? "Deleted" : "Moved to trash";
+        const parts = [];
+        const { deletedByType } = cleanResult;
+        if (deletedByType.session > 0) {
+          parts.push(`${deletedByType.session} session`);
+        }
+        if (deletedByType.sessionEnv > 0) {
+          parts.push(`${deletedByType.sessionEnv} session-env`);
+        }
+        if (deletedByType.todos > 0) {
+          parts.push(`${deletedByType.todos} todos`);
+        }
+        if (deletedByType.fileHistory > 0) {
+          parts.push(`${deletedByType.fileHistory} file-history`);
+        }
+        const summary = parts.length > 0 ? parts.join(" + ") : `${cleanResult.deletedCount} item(s)`;
+        logger.success(
+          `${action}: ${summary} (${formatSize(cleanResult.totalSizeDeleted)})`
+        );
+      }
+      if (cleanResult.configEntriesRemoved > 0) {
+        logger.success(
+          `Removed ${cleanResult.configEntriesRemoved} config entry(ies) from ~/.claude.json`
+        );
+      }
+      if (cleanResult.errors.length > 0) {
+        logger.error(
+          `Failed to clean ${cleanResult.errors.length} item(s)`
+        );
+      }
+    }
+  });
+  watcher.start();
+  process.on("SIGINT", () => {
+    console.log();
+    logger.info("Stopping watcher...");
+    watcher.stop();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+function getDefaultWatchPaths() {
+  const home = homedir5();
+  return [
+    join8(home, "dev"),
+    join8(home, "code"),
+    join8(home, "projects"),
+    join8(home, "Development"),
+    join8(home, "Developer"),
+    // macOS Xcode
+    join8(home, "Documents")
+  ];
+}
+
+// src/commands/list.ts
+import { Command as Command4 } from "commander";
+import Table2 from "cli-table3";
+import chalk5 from "chalk";
+var listCommand = new Command4("list").description("List detected AI coding tools and their data locations").option("-v, --verbose", "Show detailed information").action(async (options) => {
+  const allScanners = createAllScanners();
+  const availableScanners = await getAvailableScanners(allScanners);
+  console.log();
+  console.log(chalk5.bold("AI Coding Tools Status:"));
+  console.log();
+  const table = new Table2({
+    head: [
+      chalk5.cyan("Tool"),
+      chalk5.cyan("Status"),
+      chalk5.cyan("Data Location")
+    ],
+    style: { head: [] }
+  });
+  const toolLocations = {
+    "claude-code": getClaudeProjectsDir(),
+    cursor: getCursorWorkspaceDir()
+  };
+  for (const scanner of allScanners) {
+    const isAvailable = availableScanners.some((s) => s.name === scanner.name);
+    const status = isAvailable ? chalk5.green("Available") : chalk5.dim("Not found");
+    const location = toolLocations[scanner.name] || "Unknown";
+    table.push([scanner.name, status, isAvailable ? location : chalk5.dim(location)]);
+  }
+  console.log(table.toString());
+  if (options.verbose && availableScanners.length > 0) {
+    console.log();
+    console.log(chalk5.bold("Tool Details:"));
+    console.log();
+    for (const scanner of availableScanners) {
+      console.log(chalk5.cyan(`${scanner.name}:`));
+      switch (scanner.name) {
+        case "claude-code":
+          console.log("  Session format: Encoded project path directories");
+          console.log("  Path encoding: /path/to/project \u2192 -path-to-project");
+          break;
+        case "cursor":
+          console.log("  Session format: Hash-named directories with workspace.json");
+          console.log('  Project info: Stored in workspace.json "folder" field');
+          break;
+      }
+      console.log();
+    }
+  }
+  console.log(
+    chalk5.dim(
+      `${availableScanners.length} of ${allScanners.length} tools detected on this system.`
+    )
+  );
+});
+
+// src/commands/config.ts
+import { Command as Command5 } from "commander";
+import inquirer2 from "inquirer";
+var configCommand = new Command5("config").description(
+  "Manage configuration"
+);
+var pathsCommand = new Command5("paths").description("Manage watch paths");
+pathsCommand.command("add <path>").description("Add a watch path").action((path) => {
+  addWatchPath(path);
+  logger.success(`Added: ${path}`);
+});
+pathsCommand.command("remove <path>").description("Remove a watch path").action((path) => {
+  const removed = removeWatchPath(path);
+  if (removed) {
+    logger.success(`Removed: ${path}`);
+  } else {
+    logger.warn(`Path not found: ${path}`);
+  }
+});
+pathsCommand.command("list").description("List watch paths").action(() => {
+  const paths = getWatchPaths();
+  if (!paths || paths.length === 0) {
+    logger.info("No watch paths configured.");
+    return;
+  }
+  console.log();
+  for (const p of paths) {
+    console.log(`  ${p}`);
+  }
+});
+configCommand.addCommand(pathsCommand);
+var DEFAULT_DELAY_MINUTES2 = 5;
+var MAX_DELAY_MINUTES2 = 10;
+configCommand.command("delay [minutes]").description(`Get or set watch delay in minutes (default: ${DEFAULT_DELAY_MINUTES2}, max: ${MAX_DELAY_MINUTES2})`).action((minutes) => {
+  if (minutes === void 0) {
+    const delay = getWatchDelay() ?? DEFAULT_DELAY_MINUTES2;
+    console.log(`Watch delay: ${String(delay)} minute(s)`);
+  } else {
+    const value = parseInt(minutes, 10);
+    if (isNaN(value) || value < 1) {
+      logger.error("Invalid delay value. Must be a positive number.");
+      return;
+    }
+    if (value > MAX_DELAY_MINUTES2) {
+      logger.warn(`Maximum delay is ${String(MAX_DELAY_MINUTES2)} minutes. Setting to ${String(MAX_DELAY_MINUTES2)}.`);
+      setWatchDelay(MAX_DELAY_MINUTES2);
+      return;
+    }
+    setWatchDelay(value);
+    logger.success(`Watch delay set to ${String(value)} minute(s)`);
+  }
+});
+var DEFAULT_DEPTH = 3;
+var MAX_DEPTH = 5;
+configCommand.command("depth [level]").description("Get or set watch depth (default: 3, max: 5)").action((level) => {
+  if (level === void 0) {
+    const depth = getWatchDepth() ?? DEFAULT_DEPTH;
+    console.log(`Watch depth: ${String(depth)}`);
+  } else {
+    const value = parseInt(level, 10);
+    if (isNaN(value) || value < 1) {
+      logger.error("Invalid depth value. Must be a positive number.");
+      return;
+    }
+    if (value > MAX_DEPTH) {
+      logger.warn(`Maximum depth is ${String(MAX_DEPTH)}. Setting to ${String(MAX_DEPTH)}.`);
+    }
+    setWatchDepth(value);
+    const actualValue = Math.min(value, MAX_DEPTH);
+    logger.success(`Watch depth set to ${String(actualValue)}`);
+  }
+});
+configCommand.command("show").description("Show all configuration").action(() => {
+  const config = loadConfig();
+  console.log(JSON.stringify(config, null, 2));
+});
+configCommand.command("reset").description("Reset configuration to defaults").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+  if (!options.force) {
+    const { confirmed } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: "Reset all configuration to defaults?",
+        default: false
+      }
+    ]);
+    if (!confirmed) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  resetConfig();
+  logger.success("Configuration reset to defaults.");
+});
+
+// src/cli.ts
+var cli = new Command6().name("ai-session-tidy").description(
+  "CLI tool that detects and cleans orphaned session data from AI coding tools"
+).version(getAppVersion());
+cli.addCommand(scanCommand, { isDefault: true });
+cli.addCommand(cleanCommand);
+cli.addCommand(watchCommand);
+cli.addCommand(listCommand);
+cli.addCommand(configCommand);
+
+// src/index.ts
+cli.parse(process.argv);
+//# sourceMappingURL=index.js.map