@sooink/ai-session-tidy 0.1.1

package/src/commands/scan.ts

@@ -0,0 +1,200 @@
+import { Command } from 'commander';
+import Table from 'cli-table3';
+import ora from 'ora';
+import chalk from 'chalk';
+
+import { logger } from '../utils/logger.js';
+import { formatSize } from '../utils/size.js';
+import {
+  createAllScanners,
+  getAvailableScanners,
+  runAllScanners,
+} from '../scanners/index.js';
+import type { ScanResult } from '../scanners/types.js';
+
+interface ScanOptions {
+  verbose?: boolean;
+  json?: boolean;
+}
+
+function formatTokens(count?: number): string {
+  if (!count) return '0';
+  if (count >= 1000000) return `${(count / 1000000).toFixed(1)}M`;
+  if (count >= 1000) return `${(count / 1000).toFixed(0)}K`;
+  return count.toString();
+}
+
+export const 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: ScanOptions) => {
+    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: ScanResult[]): void {
+  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: ScanResult[], verbose?: boolean): void {
+  const allSessions = results.flatMap((r) => r.sessions);
+  const folderSessions = allSessions.filter((s) => s.type === 'session' || s.type === undefined);
+  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();
+
+  // Summary message
+  const parts: string[] = [];
+  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();
+
+  // Summary by tool
+  const summaryTable = new Table({
+    head: [
+      chalk.cyan('Tool'),
+      chalk.cyan('Sessions'),
+      chalk.cyan('Config'),
+      chalk.cyan('Env'),
+      chalk.cyan('Todos'),
+      chalk.cyan('History'),
+      chalk.cyan('Size'),
+      chalk.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 === undefined).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());
+
+  // Detailed info (verbose)
+  if (verbose && allSessions.length > 0) {
+    // Session folders
+    if (folderSessions.length > 0) {
+      console.log();
+      console.log(chalk.bold('Session Folders:'));
+      console.log();
+
+      for (const session of folderSessions) {
+        const projectName = session.projectPath.split('/').pop() || session.projectPath;
+        console.log(
+          `  ${chalk.cyan(`[${session.toolName}]`)} ${chalk.white(projectName)} ${chalk.dim(`(${formatSize(session.size)})`)}`
+        );
+        console.log(`    ${chalk.dim('→')} ${session.projectPath}`);
+        console.log(`    ${chalk.dim('Modified:')} ${session.lastModified.toLocaleDateString()}`);
+        console.log();
+      }
+    }
+
+    // Config entries
+    if (configEntries.length > 0) {
+      console.log();
+      console.log(chalk.bold('Config Entries (~/.claude.json):'));
+      console.log();
+
+      for (const entry of configEntries) {
+        const projectName = entry.projectPath.split('/').pop() || entry.projectPath;
+        console.log(
+          `  ${chalk.yellow('[config]')} ${chalk.white(projectName)}`
+        );
+        console.log(`    ${chalk.dim('→')} ${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(`    ${chalk.dim(`Cost: ${cost} | Tokens: ${inTokens} in / ${outTokens} out`)}`);
+        }
+        console.log();
+      }
+    }
+
+  }
+
+  console.log();
+  console.log(
+    chalk.dim('Run "ai-session-tidy clean" to remove orphaned sessions.')
+  );
+}

package/src/commands/watch.ts

@@ -0,0 +1,359 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join, resolve } from 'path';
+
+import { logger } from '../utils/logger.js';
+import { formatSize } from '../utils/size.js';
+import { getWatchPaths as getConfigWatchPaths, setWatchPaths, getWatchDelay, getWatchDepth } from '../utils/config.js';
+import {
+  createAllScanners,
+  getAvailableScanners,
+  runAllScanners,
+} from '../scanners/index.js';
+import { Watcher } from '../core/watcher.js';
+import { Cleaner } from '../core/cleaner.js';
+import { serviceManager } from '../core/service.js';
+
+const DEFAULT_DELAY_MINUTES = 5;
+const MAX_DELAY_MINUTES = 10;
+
+interface RunOptions {
+  delay?: string;
+  path?: string[];
+  noSave?: boolean;
+  noTrash?: boolean;
+  verbose?: boolean;
+}
+
+export const watchCommand = new Command('watch')
+  .description('Watch for project deletions and auto-clean orphaned sessions');
+
+// Run subcommand (default) - foreground execution
+const runCommand = new Command('run')
+  .description('Run watcher in foreground (default)')
+  .option(
+    '-p, --path <path>',
+    'Path to watch (can be used multiple times, saves to config)',
+    (value: string, previous: string[]) => previous.concat([value]),
+    [] as string[]
+  )
+  .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);
+
+// Start subcommand - install and start as OS service
+const startCommand = new Command('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 {
+      // Check current status
+      const currentStatus = await serviceManager.status();
+      if (currentStatus.status === 'running') {
+        logger.info('Watcher service is already running.');
+        return;
+      }
+
+      // Install and start
+      logger.info('Installing watcher service...');
+      await serviceManager.install();
+
+      logger.info('Starting watcher service...');
+      await serviceManager.start();
+
+      // Verify
+      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)}`);
+    }
+  });
+
+// Stop subcommand - stop and uninstall OS service
+const stopCommand = new Command('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)}`);
+    }
+  });
+
+// Status subcommand - show service status
+const statusCommand = new Command('status')
+  .description('Show watcher service status')
+  .option('-l, --logs [lines]', 'Show recent logs', '20')
+  .action(async (options: { logs?: string }) => {
+    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(chalk.bold('Watcher Service Status'));
+      console.log('─'.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(chalk.bold('Recent Logs:'));
+          console.log('─'.repeat(40));
+          console.log(logs.stdout);
+          console.log();
+        }
+
+        if (logs.stderr) {
+          console.log(chalk.bold.red('Error Logs:'));
+          console.log('─'.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: string): string {
+  switch (status) {
+    case 'running':
+      return chalk.green('running');
+    case 'stopped':
+      return chalk.yellow('stopped');
+    case 'not_installed':
+      return chalk.dim('not installed');
+    default:
+      return status;
+  }
+}
+
+// Add subcommands
+watchCommand.addCommand(runCommand, { isDefault: true });
+watchCommand.addCommand(startCommand);
+watchCommand.addCommand(stopCommand);
+watchCommand.addCommand(statusCommand);
+
+// The main watcher logic (foreground mode)
+async function runWatcher(options: RunOptions): Promise<void> {
+  // Priority: CLI option > config > default
+  const configDelay = getWatchDelay();
+  let delayMinutes = options.delay
+    ? parseInt(options.delay, 10)
+    : (configDelay ?? DEFAULT_DELAY_MINUTES);
+
+  // Enforce max delay
+  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 * 1000;
+
+  // Determine watch paths
+  let watchPaths: string[];
+  if (options.path && options.path.length > 0) {
+    // Use paths from -p option
+    watchPaths = options.path.map((p) => resolve(p.replace(/^~/, homedir())));
+
+    // Save to config (unless --no-save)
+    if (!options.noSave) {
+      setWatchPaths(watchPaths);
+      logger.info(`Saved watch paths to config.`);
+    }
+  } else {
+    // Read from config or use defaults
+    const configPaths = getConfigWatchPaths();
+    if (configPaths && configPaths.length > 0) {
+      watchPaths = configPaths;
+      logger.info(`Using saved watch paths from config.`);
+    } else {
+      watchPaths = getDefaultWatchPaths();
+      logger.info(`Using default watch paths.`);
+    }
+  }
+
+  // Filter to existing paths
+  const validPaths = watchPaths.filter((p) => existsSync(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) => !existsSync(p));
+    logger.warn(`Skipping non-existent paths: ${invalidPaths.join(', ')}`);
+  }
+
+  // Check scanners
+  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(chalk.dim('Press Ctrl+C to stop watching.'));
+  }
+  console.log();
+
+  const cleaner = new Cleaner();
+
+  const watcher = new Watcher({
+    watchPaths: validPaths,
+    delayMs,
+    depth,
+    onDelete: async (events) => {
+      // Log batch 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}`);
+          }
+        }
+      }
+
+      // Scan for orphaned sessions (executed only once)
+      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;
+      }
+
+      // Clean up
+      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: string[] = [];
+        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();
+
+  // Handle Ctrl+C
+  process.on('SIGINT', () => {
+    console.log();
+    logger.info('Stopping watcher...');
+    watcher.stop();
+    process.exit(0);
+  });
+
+  // Keep process alive
+  await new Promise(() => {});
+}
+
+function getDefaultWatchPaths(): string[] {
+  const home = homedir();
+  return [
+    join(home, 'dev'),
+    join(home, 'code'),
+    join(home, 'projects'),
+    join(home, 'Development'),
+    join(home, 'Developer'),    // macOS Xcode
+    join(home, 'Documents'),
+  ];
+}

package/src/core/cleaner.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm, access } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+import { Cleaner, CleanResult, CleanOptions } from './cleaner.js';
+import type { OrphanedSession } from '../scanners/types.js';
+
+describe('Cleaner', () => {
+  const testDir = join(tmpdir(), 'cleanertest' + Date.now());
+
+  beforeEach(async () => {
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function createSession(
+    sessionPath: string,
+    size: number = 100
+  ): OrphanedSession {
+    return {
+      toolName: 'claude-code',
+      sessionPath,
+      projectPath: '/deleted/project',
+      size,
+      lastModified: new Date(),
+    };
+  }
+
+  describe('clean', () => {
+    it('does not delete in dry-run mode', async () => {
+      const sessionDir = join(testDir, 'session1');
+      await mkdir(sessionDir);
+      await writeFile(join(sessionDir, 'data.json'), 'content');
+
+      const sessions = [createSession(sessionDir)];
+      const cleaner = new Cleaner();
+
+      const result = await cleaner.clean(sessions, { dryRun: true });
+
+      // File should still exist
+      await expect(access(sessionDir)).resolves.not.toThrow();
+      expect(result.deletedCount).toBe(0);
+      expect(result.skippedCount).toBe(1);
+    });
+
+    it('moves to trash (default)', async () => {
+      const sessionDir = join(testDir, 'session2');
+      await mkdir(sessionDir);
+      await writeFile(join(sessionDir, 'data.json'), 'content');
+
+      const sessions = [createSession(sessionDir, 50)];
+      const cleaner = new Cleaner();
+
+      const result = await cleaner.clean(sessions, { dryRun: false });
+
+      // File should be deleted
+      await expect(access(sessionDir)).rejects.toThrow();
+      expect(result.deletedCount).toBe(1);
+      expect(result.totalSizeDeleted).toBe(50);
+    });
+
+    it('permanently deletes with --no-trash', async () => {
+      const sessionDir = join(testDir, 'session3');
+      await mkdir(sessionDir);
+      await writeFile(join(sessionDir, 'data.json'), 'content');
+
+      const sessions = [createSession(sessionDir)];
+      const cleaner = new Cleaner();
+
+      const result = await cleaner.clean(sessions, {
+        dryRun: false,
+        useTrash: false,
+      });
+
+      await expect(access(sessionDir)).rejects.toThrow();
+      expect(result.deletedCount).toBe(1);
+    });
+
+    it('returns cleanup statistics', async () => {
+      const session1 = join(testDir, 'stat1');
+      const session2 = join(testDir, 'stat2');
+      await mkdir(session1);
+      await mkdir(session2);
+      await writeFile(join(session1, 'data.json'), 'a');
+      await writeFile(join(session2, 'data.json'), 'b');
+
+      const sessions = [
+        createSession(session1, 100),
+        createSession(session2, 200),
+      ];
+      const cleaner = new Cleaner();
+
+      const result = await cleaner.clean(sessions, { dryRun: false });
+
+      expect(result.deletedCount).toBe(2);
+      expect(result.totalSizeDeleted).toBe(300);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('handles already deleted paths with alreadyGoneCount', async () => {
+      // Non-existent path (already deleted)
+      const sessions = [createSession('/nonexistent/path/12345')];
+      const cleaner = new Cleaner();
+
+      const result = await cleaner.clean(sessions, { dryRun: false });
+
+      expect(result.deletedCount).toBe(0);
+      expect(result.alreadyGoneCount).toBe(1);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('handles empty session list', async () => {
+      const cleaner = new Cleaner();
+      const result = await cleaner.clean([], { dryRun: false });
+
+      expect(result.deletedCount).toBe(0);
+      expect(result.totalSizeDeleted).toBe(0);
+    });
+  });
+});