@sooink/ai-session-tidy 0.1.1

package/src/scanners/cursor.ts

@@ -0,0 +1,133 @@
+import { readdir, readFile, stat, access } from 'fs/promises';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+import type { Scanner, ScanResult, OrphanedSession } from './types.js';
+import { getCursorWorkspaceDir } from '../utils/paths.js';
+import { getDirectorySize } from '../utils/size.js';
+
+interface WorkspaceJson {
+  folder?: string;
+}
+
+export class CursorScanner implements Scanner {
+  readonly name = 'cursor' as const;
+  private readonly workspaceDir: string;
+
+  constructor(workspaceDir?: string) {
+    this.workspaceDir = workspaceDir ?? getCursorWorkspaceDir();
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await access(this.workspaceDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async scan(): Promise<ScanResult> {
+    const startTime = performance.now();
+    const sessions: OrphanedSession[] = [];
+
+    if (!(await this.isAvailable())) {
+      return {
+        toolName: this.name,
+        sessions: [],
+        totalSize: 0,
+        scanDuration: performance.now() - startTime,
+      };
+    }
+
+    const entries = await readdir(this.workspaceDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+
+      const sessionPath = join(this.workspaceDir, entry.name);
+      const workspaceJsonPath = join(sessionPath, 'workspace.json');
+
+      // Read workspace.json
+      const projectPath = await this.parseWorkspaceJson(workspaceJsonPath);
+      if (!projectPath) continue;
+
+      // Check if original project exists
+      const projectExists = await this.pathExists(projectPath);
+      if (projectExists) continue;
+
+      // Calculate session size
+      const size = await getDirectorySize(sessionPath);
+
+      // Get last modified time
+      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,
+    };
+  }
+
+  private async parseWorkspaceJson(
+    workspaceJsonPath: string
+  ): Promise<string | null> {
+    try {
+      const content = await readFile(workspaceJsonPath, 'utf-8');
+      const data: WorkspaceJson = JSON.parse(content);
+
+      if (!data.folder) return null;
+
+      // Convert file:// URL to regular path
+      if (data.folder.startsWith('file://')) {
+        return fileURLToPath(data.folder);
+      }
+
+      return data.folder;
+    } catch {
+      return 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/index.ts

@@ -0,0 +1,39 @@
+import type { Scanner, ScanResult } from './types.js';
+import { ClaudeCodeScanner } from './claude-code.js';
+import { CursorScanner } from './cursor.js';
+
+export { ClaudeCodeScanner } from './claude-code.js';
+export { CursorScanner } from './cursor.js';
+export * from './types.js';
+
+/**
+ * Create all scanner instances
+ */
+export function createAllScanners(): Scanner[] {
+  return [new ClaudeCodeScanner(), new CursorScanner()];
+}
+
+/**
+ * Filter to available scanners only
+ */
+export async function getAvailableScanners(
+  scanners: Scanner[]
+): Promise<Scanner[]> {
+  const results = await Promise.all(
+    scanners.map(async (scanner) => ({
+      scanner,
+      available: await scanner.isAvailable(),
+    }))
+  );
+
+  return results.filter((r) => r.available).map((r) => r.scanner);
+}
+
+/**
+ * Run all scanners and merge results
+ */
+export async function runAllScanners(
+  scanners: Scanner[]
+): Promise<ScanResult[]> {
+  return Promise.all(scanners.map((scanner) => scanner.scan()));
+}

package/src/scanners/types.ts

@@ -0,0 +1,34 @@
+export type ToolName = 'claude-code' | 'cursor';
+
+export type SessionType = 'session' | 'config' | 'session-env' | 'todos' | 'file-history';
+
+export interface ConfigStats {
+  lastCost?: number;
+  lastTotalInputTokens?: number;
+  lastTotalOutputTokens?: number;
+}
+
+export interface OrphanedSession {
+  toolName: ToolName;
+  sessionPath: string;
+  projectPath: string;
+  size: number;
+  lastModified: Date;
+  /** 'session' = folder, 'config' = JSON config entry */
+  type?: SessionType;
+  /** Stats for config entries (cost, tokens) */
+  configStats?: ConfigStats;
+}
+
+export interface ScanResult {
+  toolName: ToolName;
+  sessions: OrphanedSession[];
+  totalSize: number;
+  scanDuration: number;
+}
+
+export interface Scanner {
+  name: ToolName;
+  isAvailable(): Promise<boolean>;
+  scan(): Promise<ScanResult>;
+}

package/src/utils/config.ts

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const CONFIG_VERSION = '0.1';
+
+export function getAppVersion(): string {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  // Try multiple paths (source vs bundled)
+  const paths = [
+    join(__dirname, '..', '..', 'package.json'), // from src/utils/
+    join(__dirname, '..', 'package.json'),       // from dist/
+  ];
+
+  for (const packagePath of paths) {
+    try {
+      if (existsSync(packagePath)) {
+        const content = readFileSync(packagePath, 'utf-8');
+        const pkg = JSON.parse(content) as { version: string };
+        return pkg.version;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return 'unknown';
+}
+
+export interface Config {
+  version?: string; // app version that last saved this config
+  configVersion?: string; // config schema version
+  watchPaths?: string[];
+  watchDelay?: number; // minutes
+  watchDepth?: number; // folder depth (default: 3, max: 5)
+}
+
+function getConfigPath(): string {
+  return join(homedir(), '.config', 'ai-session-tidy', 'config.json');
+}
+
+export function loadConfig(): Config {
+  const configPath = getConfigPath();
+
+  if (!existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    return JSON.parse(content) as Config;
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(config: Config): void {
+  const configPath = getConfigPath();
+  const configDir = dirname(configPath);
+
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+
+  const configWithVersion: Config = {
+    version: getAppVersion(),
+    configVersion: CONFIG_VERSION,
+    ...config,
+  };
+
+  writeFileSync(configPath, JSON.stringify(configWithVersion, null, 2), 'utf-8');
+}
+
+export function getWatchPaths(): string[] | undefined {
+  const config = loadConfig();
+  return config.watchPaths;
+}
+
+export function setWatchPaths(paths: string[]): void {
+  const config = loadConfig();
+  config.watchPaths = paths;
+  saveConfig(config);
+}
+
+export function addWatchPath(path: string): void {
+  const config = loadConfig();
+  const resolved = resolve(path.replace(/^~/, homedir()));
+  const paths = config.watchPaths ?? [];
+  if (!paths.includes(resolved)) {
+    paths.push(resolved);
+    config.watchPaths = paths;
+    saveConfig(config);
+  }
+}
+
+export function removeWatchPath(path: string): boolean {
+  const config = loadConfig();
+  const resolved = resolve(path.replace(/^~/, homedir()));
+  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;
+}
+
+export function getWatchDelay(): number | undefined {
+  const config = loadConfig();
+  return config.watchDelay;
+}
+
+export function setWatchDelay(minutes: number): void {
+  const config = loadConfig();
+  config.watchDelay = minutes;
+  saveConfig(config);
+}
+
+export function getWatchDepth(): number | undefined {
+  const config = loadConfig();
+  return config.watchDepth;
+}
+
+export function setWatchDepth(depth: number): void {
+  const config = loadConfig();
+  config.watchDepth = Math.min(depth, 5); // max 5
+  saveConfig(config);
+}
+
+export function resetConfig(): void {
+  saveConfig({});
+}

package/src/utils/logger.ts

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+
+export interface Logger {
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+  success(message: string): void;
+  debug(message: string): void;
+}
+
+export const logger: Logger = {
+  info(message: string): void {
+    console.log(chalk.blue('ℹ'), message);
+  },
+  warn(message: string): void {
+    console.log(chalk.yellow('⚠'), message);
+  },
+  error(message: string): void {
+    console.log(chalk.red('✖'), message);
+  },
+  success(message: string): void {
+    console.log(chalk.green('✔'), message);
+  },
+  debug(message: string): void {
+    if (process.env['DEBUG']) {
+      console.log(chalk.gray('🐛'), message);
+    }
+  },
+};

package/src/utils/paths.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { homedir } from 'os';
+import { join } from 'path';
+
+import { encodePath, decodePath, getConfigDir } from './paths.js';
+
+describe('encodePath', () => {
+  it('converts slashes to dashes', () => {
+    expect(encodePath('/home/user/project')).toBe('-home-user-project');
+  });
+
+  it('handles empty string', () => {
+    expect(encodePath('')).toBe('');
+  });
+
+  it('handles root path', () => {
+    expect(encodePath('/')).toBe('-');
+  });
+
+  it('keeps Windows style paths unchanged', () => {
+    expect(encodePath('C:\\Users\\project')).toBe('C:\\Users\\project');
+  });
+});
+
+describe('decodePath', () => {
+  it('restores dashes to slashes', () => {
+    expect(decodePath('-home-user-project')).toBe('/home/user/project');
+  });
+
+  it('handles empty string', () => {
+    expect(decodePath('')).toBe('');
+  });
+
+  it('restores single dash to root', () => {
+    expect(decodePath('-')).toBe('/');
+  });
+});
+
+describe('getConfigDir', () => {
+  const originalPlatform = process.platform;
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('returns Application Support path on macOS', () => {
+    vi.stubGlobal('process', { ...process, platform: 'darwin' });
+    expect(getConfigDir('TestApp')).toBe(
+      join(homedir(), 'Library/Application Support', 'TestApp')
+    );
+  });
+
+  it('returns APPDATA path on Windows', () => {
+    const mockAppData = 'C:\\Users\\Test\\AppData\\Roaming';
+    vi.stubGlobal('process', {
+      ...process,
+      platform: 'win32',
+      env: { ...process.env, APPDATA: mockAppData },
+    });
+    expect(getConfigDir('TestApp')).toBe(join(mockAppData, 'TestApp'));
+  });
+
+  it('returns .config path on Linux', () => {
+    vi.stubGlobal('process', { ...process, platform: 'linux' });
+    expect(getConfigDir('TestApp')).toBe(join(homedir(), '.config', 'TestApp'));
+  });
+});
+
+describe('getClaudeProjectsDir', () => {
+  it('returns ~/.claude/projects path', async () => {
+    const { getClaudeProjectsDir } = await import('./paths.js');
+    expect(getClaudeProjectsDir()).toBe(join(homedir(), '.claude', 'projects'));
+  });
+});
+
+describe('getCursorWorkspaceDir', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('returns Cursor workspaceStorage path on macOS', async () => {
+    vi.stubGlobal('process', { ...process, platform: 'darwin' });
+    const { getCursorWorkspaceDir } = await import('./paths.js');
+    expect(getCursorWorkspaceDir()).toBe(
+      join(
+        homedir(),
+        'Library/Application Support',
+        'Cursor',
+        'User',
+        'workspaceStorage'
+      )
+    );
+  });
+});
+

package/src/utils/paths.ts

@@ -0,0 +1,92 @@
+import { homedir } from 'os';
+import { join } from 'path';
+
+/**
+ * Encode Unix path to Claude Code style
+ * /home/user/project → -home-user-project
+ */
+export function encodePath(path: string): string {
+  if (path === '') return '';
+  // Only convert Unix slashes, leave Windows paths as-is
+  if (!path.includes('/')) return path;
+  return path.replace(/\//g, '-');
+}
+
+/**
+ * Decode Claude Code encoded path to Unix path
+ * -home-user-project → /home/user/project
+ */
+export function decodePath(encoded: string): string {
+  if (encoded === '') return '';
+  // Treat as Unix encoding if it starts with a dash
+  if (!encoded.startsWith('-')) return encoded;
+  return encoded.replace(/-/g, '/');
+}
+
+/**
+ * Return platform-specific application config directory
+ */
+export function getConfigDir(appName: string): string {
+  switch (process.platform) {
+    case 'darwin':
+      return join(homedir(), 'Library/Application Support', appName);
+    case 'win32':
+      return join(process.env['APPDATA'] || '', appName);
+    default:
+      return join(homedir(), '.config', appName);
+  }
+}
+
+/**
+ * Claude Code projects directory path
+ */
+export function getClaudeProjectsDir(): string {
+  return join(homedir(), '.claude', 'projects');
+}
+
+/**
+ * Claude Code global config file path (~/.claude.json)
+ */
+export function getClaudeConfigPath(): string {
+  return join(homedir(), '.claude.json');
+}
+
+/**
+ * Cursor workspaceStorage directory path
+ */
+export function getCursorWorkspaceDir(): string {
+  return join(getConfigDir('Cursor'), 'User', 'workspaceStorage');
+}
+
+/**
+ * Claude Code session environment directory path (~/.claude/session-env)
+ */
+export function getClaudeSessionEnvDir(): string {
+  return join(homedir(), '.claude', 'session-env');
+}
+
+/**
+ * Claude Code todos directory path (~/.claude/todos)
+ */
+export function getClaudeTodosDir(): string {
+  return join(homedir(), '.claude', 'todos');
+}
+
+/**
+ * Claude Code file-history directory path (~/.claude/file-history)
+ */
+export function getClaudeFileHistoryDir(): string {
+  return join(homedir(), '.claude', 'file-history');
+}
+
+/**
+ * Replace home directory with ~ for display
+ * /Users/user/.ai-session-tidy → ~/.ai-session-tidy
+ */
+export function tildify(path: string): string {
+  const home = homedir();
+  if (path.startsWith(home)) {
+    return path.replace(home, '~');
+  }
+  return path;
+}

package/src/utils/size.test.ts

@@ -0,0 +1,80 @@
+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 { formatSize, getDirectorySize } from './size.js';
+
+describe('formatSize', () => {
+  it('formats bytes (< 1KB)', () => {
+    expect(formatSize(0)).toBe('0 B');
+    expect(formatSize(500)).toBe('500 B');
+    expect(formatSize(1023)).toBe('1023 B');
+  });
+
+  it('formats KB (< 1MB)', () => {
+    expect(formatSize(1024)).toBe('1.0 KB');
+    expect(formatSize(1536)).toBe('1.5 KB');
+    expect(formatSize(10240)).toBe('10.0 KB');
+  });
+
+  it('formats MB (< 1GB)', () => {
+    expect(formatSize(1048576)).toBe('1.0 MB');
+    expect(formatSize(1572864)).toBe('1.5 MB');
+    expect(formatSize(104857600)).toBe('100.0 MB');
+  });
+
+  it('formats GB', () => {
+    expect(formatSize(1073741824)).toBe('1.0 GB');
+    expect(formatSize(1610612736)).toBe('1.5 GB');
+  });
+
+  it('treats negative as 0', () => {
+    expect(formatSize(-100)).toBe('0 B');
+  });
+});
+
+describe('getDirectorySize', () => {
+  const testDir = join(tmpdir(), 'size-test-' + Date.now());
+
+  beforeEach(async () => {
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  it('returns 0 for empty directory', async () => {
+    const size = await getDirectorySize(testDir);
+    expect(size).toBe(0);
+  });
+
+  it('calculates single file size', async () => {
+    const content = 'a'.repeat(1000);
+    await writeFile(join(testDir, 'file.txt'), content);
+    const size = await getDirectorySize(testDir);
+    expect(size).toBe(1000);
+  });
+
+  it('calculates total size of multiple files', async () => {
+    await writeFile(join(testDir, 'file1.txt'), 'a'.repeat(500));
+    await writeFile(join(testDir, 'file2.txt'), 'b'.repeat(300));
+    const size = await getDirectorySize(testDir);
+    expect(size).toBe(800);
+  });
+
+  it('includes nested directory sizes', async () => {
+    const subDir = join(testDir, 'subdir');
+    await mkdir(subDir, { recursive: true });
+    await writeFile(join(testDir, 'root.txt'), 'a'.repeat(100));
+    await writeFile(join(subDir, 'nested.txt'), 'b'.repeat(200));
+    const size = await getDirectorySize(testDir);
+    expect(size).toBe(300);
+  });
+
+  it('returns 0 for non-existent directory', async () => {
+    const size = await getDirectorySize('/nonexistent/path/12345');
+    expect(size).toBe(0);
+  });
+});

package/src/utils/size.ts

@@ -0,0 +1,50 @@
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+
+const UNITS = ['B', 'KB', 'MB', 'GB', 'TB'] as const;
+
+/**
+ * Format byte size to human-readable format
+ */
+export function formatSize(bytes: number): string {
+  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]}`;
+}
+
+/**
+ * Recursively calculate total size of a directory
+ */
+export async function getDirectorySize(dirPath: string): Promise<number> {
+  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;
+  }
+}