@sooink/ai-session-tidy 0.1.1

package/src/scanners/claude-code.ts

@@ -0,0 +1,452 @@
+import { readdir, readFile, stat, access } from 'fs/promises';
+import { join } from 'path';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
+
+import type { Scanner, ScanResult, OrphanedSession } from './types.js';
+import {
+  decodePath,
+  getClaudeProjectsDir,
+  getClaudeConfigPath,
+  getClaudeSessionEnvDir,
+  getClaudeTodosDir,
+  getClaudeFileHistoryDir,
+} from '../utils/paths.js';
+import { getDirectorySize } from '../utils/size.js';
+
+interface ClaudeProjectData {
+  lastCost?: number;
+  lastTotalInputTokens?: number;
+  lastTotalOutputTokens?: number;
+  [key: string]: unknown;
+}
+
+interface ClaudeConfig {
+  projects?: Record<string, ClaudeProjectData>;
+  [key: string]: unknown;
+}
+
+interface SessionEntry {
+  cwd?: string;
+}
+
+export interface ClaudeCodeScannerOptions {
+  projectsDir?: string;
+  configPath?: string | null; // null to disable config scanning
+  sessionEnvDir?: string | null; // null to disable session-env scanning
+  todosDir?: string | null; // null to disable todos scanning
+  fileHistoryDir?: string | null; // null to disable file-history scanning
+}
+
+export class ClaudeCodeScanner implements Scanner {
+  readonly name = 'claude-code' as const;
+  private readonly projectsDir: string;
+  private readonly configPath: string | null;
+  private readonly sessionEnvDir: string | null;
+  private readonly todosDir: string | null;
+  private readonly fileHistoryDir: string | null;
+
+  constructor(projectsDirOrOptions?: string | ClaudeCodeScannerOptions) {
+    if (typeof projectsDirOrOptions === 'string') {
+      // Backward compatibility: treat string as projectsDir, disable other scans
+      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 === undefined
+        ? getClaudeConfigPath()
+        : projectsDirOrOptions.configPath;
+      this.sessionEnvDir = projectsDirOrOptions.sessionEnvDir === undefined
+        ? getClaudeSessionEnvDir()
+        : projectsDirOrOptions.sessionEnvDir;
+      this.todosDir = projectsDirOrOptions.todosDir === undefined
+        ? getClaudeTodosDir()
+        : projectsDirOrOptions.todosDir;
+      this.fileHistoryDir = projectsDirOrOptions.fileHistoryDir === undefined
+        ? getClaudeFileHistoryDir()
+        : projectsDirOrOptions.fileHistoryDir;
+    } else {
+      this.projectsDir = getClaudeProjectsDir();
+      this.configPath = getClaudeConfigPath();
+      this.sessionEnvDir = getClaudeSessionEnvDir();
+      this.todosDir = getClaudeTodosDir();
+      this.fileHistoryDir = getClaudeFileHistoryDir();
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await access(this.projectsDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async scan(): Promise<ScanResult> {
+    const startTime = performance.now();
+    const sessions: OrphanedSession[] = [];
+
+    // 1. Scan session folders
+    if (await this.isAvailable()) {
+      const entries = await readdir(this.projectsDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const sessionPath = join(this.projectsDir, entry.name);
+
+        // Extract actual project path from JSONL file
+        let projectPath = await this.extractProjectPath(sessionPath);
+
+        // Fallback to decoding if path not found in JSONL
+        if (!projectPath) {
+          projectPath = decodePath(entry.name);
+        }
+
+        // Check if original project exists
+        const projectExists = await this.pathExists(projectPath);
+        if (projectExists) continue;
+
+        // Exclude empty directories
+        const size = await getDirectorySize(sessionPath);
+        if (size === 0) continue;
+
+        // Get last modified time
+        const lastModified = await this.getLastModified(sessionPath);
+
+        sessions.push({
+          toolName: this.name,
+          sessionPath,
+          projectPath,
+          size,
+          lastModified,
+          type: 'session',
+        });
+      }
+    }
+
+    // 2. Scan ~/.claude.json config file
+    const configSessions = await this.scanConfigFile();
+    sessions.push(...configSessions);
+
+    // 3. Scan ~/.claude/session-env empty folders
+    const sessionEnvSessions = await this.scanSessionEnvDir();
+    sessions.push(...sessionEnvSessions);
+
+    // 4. Collect valid session UUIDs then scan todos/file-history
+    const validSessionIds = await this.collectValidSessionIds();
+
+    // 5. Scan ~/.claude/todos for orphaned files
+    const todosSessions = await this.scanTodosDir(validSessionIds);
+    sessions.push(...todosSessions);
+
+    // 6. Scan ~/.claude/file-history for orphaned folders
+    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
+   */
+  private async scanConfigFile(): Promise<OrphanedSession[]> {
+    if (!this.configPath) {
+      return [];
+    }
+
+    const configPath = this.configPath;
+    const orphanedConfigs: OrphanedSession[] = [];
+
+    try {
+      const content = await readFile(configPath, 'utf-8');
+      const config: ClaudeConfig = JSON.parse(content);
+      const configStat = await stat(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 {
+      // Ignore if config file doesn't exist or read fails
+    }
+
+    return orphanedConfigs;
+  }
+
+  /**
+   * Detect empty session environment folders from ~/.claude/session-env
+   */
+  private async scanSessionEnvDir(): Promise<OrphanedSession[]> {
+    if (!this.sessionEnvDir) {
+      return [];
+    }
+
+    const orphanedEnvs: OrphanedSession[] = [];
+
+    try {
+      await access(this.sessionEnvDir);
+      const entries = await readdir(this.sessionEnvDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const envPath = join(this.sessionEnvDir, entry.name);
+        const files = await readdir(envPath);
+
+        // Only treat empty folders as orphaned
+        if (files.length === 0) {
+          const envStat = await stat(envPath);
+          orphanedEnvs.push({
+            toolName: this.name,
+            sessionPath: envPath,
+            projectPath: entry.name, // UUID
+            size: 0,
+            lastModified: envStat.mtime,
+            type: 'session-env',
+          });
+        }
+      }
+    } catch {
+      // Ignore if directory doesn't exist or access fails
+    }
+
+    return orphanedEnvs;
+  }
+
+  /**
+   * Collect valid session UUIDs from all projects
+   */
+  private async collectValidSessionIds(): Promise<Set<string>> {
+    const sessionIds = new Set<string>();
+
+    try {
+      const projectDirs = await readdir(this.projectsDir, { withFileTypes: true });
+
+      for (const projectDir of projectDirs) {
+        if (!projectDir.isDirectory()) continue;
+
+        const projectPath = join(this.projectsDir, projectDir.name);
+        const files = await readdir(projectPath);
+
+        for (const file of files) {
+          if (file.endsWith('.jsonl')) {
+            // Extract UUID from UUID.jsonl
+            const sessionId = file.replace('.jsonl', '');
+            sessionIds.add(sessionId);
+          }
+        }
+      }
+    } catch {
+      // Return empty Set if directory access fails
+    }
+
+    return sessionIds;
+  }
+
+  /**
+   * Detect orphaned todo files from ~/.claude/todos
+   * Filename pattern: {session-uuid}-agent-{agent-uuid}.json
+   */
+  private async scanTodosDir(validSessionIds: Set<string>): Promise<OrphanedSession[]> {
+    if (!this.todosDir) {
+      return [];
+    }
+
+    const orphanedTodos: OrphanedSession[] = [];
+
+    try {
+      await access(this.todosDir);
+      const entries = await readdir(this.todosDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+
+        // Extract session UUID from filename (first UUID)
+        const sessionId = entry.name.split('-agent-')[0];
+        if (!sessionId) continue;
+
+        // Orphan if not in valid session IDs
+        if (!validSessionIds.has(sessionId)) {
+          const todoPath = join(this.todosDir, entry.name);
+          const todoStat = await stat(todoPath);
+
+          orphanedTodos.push({
+            toolName: this.name,
+            sessionPath: todoPath,
+            projectPath: sessionId, // Session UUID
+            size: todoStat.size,
+            lastModified: todoStat.mtime,
+            type: 'todos',
+          });
+        }
+      }
+    } catch {
+      // Ignore if directory doesn't exist or access fails
+    }
+
+    return orphanedTodos;
+  }
+
+  /**
+   * Detect orphaned folders from ~/.claude/file-history
+   * Folder name is the session UUID
+   */
+  private async scanFileHistoryDir(validSessionIds: Set<string>): Promise<OrphanedSession[]> {
+    if (!this.fileHistoryDir) {
+      return [];
+    }
+
+    const orphanedHistories: OrphanedSession[] = [];
+
+    try {
+      await access(this.fileHistoryDir);
+      const entries = await readdir(this.fileHistoryDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const sessionId = entry.name;
+
+        // Orphan if not in valid session IDs
+        if (!validSessionIds.has(sessionId)) {
+          const historyPath = join(this.fileHistoryDir, entry.name);
+          const size = await getDirectorySize(historyPath);
+          const historyStat = await stat(historyPath);
+
+          orphanedHistories.push({
+            toolName: this.name,
+            sessionPath: historyPath,
+            projectPath: sessionId, // Session UUID
+            size,
+            lastModified: historyStat.mtime,
+            type: 'file-history',
+          });
+        }
+      }
+    } catch {
+      // Ignore if directory doesn't exist or access fails
+    }
+
+    return orphanedHistories;
+  }
+
+  /**
+   * Extract project path (cwd) from JSONL file
+   */
+  private async extractProjectPath(sessionDir: string): Promise<string | null> {
+    try {
+      const files = await readdir(sessionDir);
+      const jsonlFile = files.find((f) => f.endsWith('.jsonl'));
+
+      if (!jsonlFile) return null;
+
+      const jsonlPath = join(sessionDir, jsonlFile);
+
+      // Read only first few lines to find cwd
+      const cwd = await this.findCwdInJsonl(jsonlPath);
+      return cwd;
+    } catch {
+      return null;
+    }
+  }
+
+  private async findCwdInJsonl(jsonlPath: string): Promise<string | null> {
+    return new Promise((resolve) => {
+      const stream = createReadStream(jsonlPath, { encoding: 'utf-8' });
+      const rl = createInterface({ input: stream, crlfDelay: Infinity });
+
+      let found = false;
+      let lineCount = 0;
+      const maxLines = 10; // Check only first 10 lines
+
+      rl.on('line', (line) => {
+        if (found || lineCount >= maxLines) {
+          rl.close();
+          return;
+        }
+
+        lineCount++;
+
+        try {
+          const entry: SessionEntry = JSON.parse(line);
+          if (entry.cwd) {
+            found = true;
+            rl.close();
+            stream.destroy();
+            resolve(entry.cwd);
+          }
+        } catch {
+          // Ignore JSON parse failures
+        }
+      });
+
+      rl.on('close', () => {
+        if (!found) resolve(null);
+      });
+
+      rl.on('error', () => {
+        resolve(null);
+      });
+    });
+  }
+
+  private async pathExists(path: string): Promise<boolean> {
+    try {
+      await access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async getLastModified(dirPath: string): Promise<Date> {
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      let latestTime = 0;
+
+      for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+        const fileStat = await stat(fullPath);
+        const mtime = fileStat.mtimeMs;
+
+        if (mtime > latestTime) {
+          latestTime = mtime;
+        }
+      }
+
+      return latestTime > 0 ? new Date(latestTime) : new Date();
+    } catch {
+      return new Date();
+    }
+  }
+}

package/src/scanners/cursor.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+import { CursorScanner } from './cursor.js';
+
+describe('CursorScanner', () => {
+  const testBaseDir = join(tmpdir(), 'cursortest' + Date.now());
+  const mockWorkspaceDir = join(testBaseDir, 'workspaceStorage');
+
+  beforeEach(async () => {
+    await mkdir(mockWorkspaceDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testBaseDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  describe('isAvailable', () => {
+    it('returns true when workspaceStorage directory exists', async () => {
+      const scanner = new CursorScanner(mockWorkspaceDir);
+      expect(await scanner.isAvailable()).toBe(true);
+    });
+
+    it('returns false when directory does not exist', async () => {
+      const scanner = new CursorScanner('/nonexistent/path/12345');
+      expect(await scanner.isAvailable()).toBe(false);
+    });
+  });
+
+  describe('scan', () => {
+    it('parses project path from workspace.json', async () => {
+      const workspaceHash = 'abc123';
+      const workspaceDir = join(mockWorkspaceDir, workspaceHash);
+      await mkdir(workspaceDir, { recursive: true });
+
+      // Create workspace.json (deleted project path)
+      const workspaceJson = {
+        folder: 'file:///deleted/project/path',
+      };
+      await writeFile(
+        join(workspaceDir, 'workspace.json'),
+        JSON.stringify(workspaceJson)
+      );
+      // Add other files (for size calculation test)
+      await writeFile(join(workspaceDir, 'state.vscdb'), 'database content');
+
+      const scanner = new CursorScanner(mockWorkspaceDir);
+      const result = await scanner.scan();
+
+      expect(result.sessions).toHaveLength(1);
+      expect(result.sessions[0].projectPath).toBe('/deleted/project/path');
+      expect(result.sessions[0].toolName).toBe('cursor');
+    });
+
+    it('excludes active projects (original exists)', async () => {
+      // Create actually existing directory
+      const realProjectDir = join(testBaseDir, 'existingproject');
+      await mkdir(realProjectDir, { recursive: true });
+
+      const workspaceHash = 'def456';
+      const workspaceDir = join(mockWorkspaceDir, workspaceHash);
+      await mkdir(workspaceDir, { recursive: true });
+
+      const workspaceJson = {
+        folder: `file://${realProjectDir}`,
+      };
+      await writeFile(
+        join(workspaceDir, 'workspace.json'),
+        JSON.stringify(workspaceJson)
+      );
+      await writeFile(join(workspaceDir, 'state.vscdb'), 'data');
+
+      const scanner = new CursorScanner(mockWorkspaceDir);
+      const result = await scanner.scan();
+
+      expect(result.sessions).toHaveLength(0);
+    });
+
+    it('ignores directories without workspace.json', async () => {
+      const workspaceHash = 'noworkspace';
+      const workspaceDir = join(mockWorkspaceDir, workspaceHash);
+      await mkdir(workspaceDir, { recursive: true });
+      await writeFile(join(workspaceDir, 'other.txt'), 'content');
+
+      const scanner = new CursorScanner(mockWorkspaceDir);
+      const result = await scanner.scan();
+
+      expect(result.sessions).toHaveLength(0);
+    });
+
+    it('ignores invalid workspace.json', async () => {
+      const workspaceHash = 'badjson';
+      const workspaceDir = join(mockWorkspaceDir, workspaceHash);
+      await mkdir(workspaceDir, { recursive: true });
+      await writeFile(join(workspaceDir, 'workspace.json'), 'invalid json{');
+
+      const scanner = new CursorScanner(mockWorkspaceDir);
+      const result = await scanner.scan();
+
+      expect(result.sessions).toHaveLength(0);
+    });
+
+    it('ignores workspace.json without folder field', async () => {
+      const workspaceHash = 'nofolder';
+      const workspaceDir = join(mockWorkspaceDir, workspaceHash);
+      await mkdir(workspaceDir, { recursive: true });
+      await writeFile(
+        join(workspaceDir, 'workspace.json'),
+        JSON.stringify({ workspace: 'something' })
+      );
+
+      const scanner = new CursorScanner(mockWorkspaceDir);
+      const result = await scanner.scan();
+
+      expect(result.sessions).toHaveLength(0);
+    });
+
+    it('calculates session size and modified time', async () => {
+      const workspaceHash = 'sizetest';
+      const workspaceDir = join(mockWorkspaceDir, workspaceHash);
+      await mkdir(workspaceDir, { recursive: true });
+
+      await writeFile(
+        join(workspaceDir, 'workspace.json'),
+        JSON.stringify({ folder: 'file:///orphan/project' })
+      );
+      await writeFile(join(workspaceDir, 'data.db'), 'a'.repeat(1000));
+
+      const scanner = new CursorScanner(mockWorkspaceDir);
+      const result = await scanner.scan();
+
+      expect(result.sessions[0].size).toBeGreaterThan(0);
+      expect(result.sessions[0].lastModified).toBeInstanceOf(Date);
+      expect(result.totalSize).toBe(result.sessions[0].size);
+    });
+  });
+});