@sooink/ai-session-tidy 0.1.1

package/src/commands/clean.ts

@@ -0,0 +1,335 @@
+import { basename } from 'path';
+
+import { Command } from 'commander';
+import ora from 'ora';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+import { logger } from '../utils/logger.js';
+import { formatSize } from '../utils/size.js';
+import { tildify } from '../utils/paths.js';
+import {
+  createAllScanners,
+  getAvailableScanners,
+  runAllScanners,
+} from '../scanners/index.js';
+import { Cleaner } from '../core/cleaner.js';
+import type { OrphanedSession } from '../scanners/types.js';
+
+interface CleanOptions {
+  force?: boolean;
+  dryRun?: boolean;
+  noTrash?: boolean;
+  verbose?: boolean;
+  interactive?: boolean;
+}
+
+function formatSessionChoice(session: OrphanedSession): string {
+  const projectName = basename(session.projectPath);
+  const isConfig = session.type === 'config';
+  const toolTag = isConfig
+    ? chalk.yellow('[config]')
+    : chalk.cyan(`[${session.toolName}]`);
+  const name = chalk.white(projectName);
+  const size = isConfig ? '' : chalk.dim(`(${formatSize(session.size)})`);
+  const path = chalk.dim(`→ ${session.projectPath}`);
+  return `${toolTag} ${name} ${size}\n    ${path}`;
+}
+
+export const cleanCommand = new Command('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: CleanOptions) => {
+    const spinner = ora('Scanning for orphaned sessions...').start();
+
+    try {
+      // Scan
+      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;
+      }
+
+      // Separate session folders, config entries, and auto-cleanup targets
+      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'
+      );
+
+      // Auto-cleanup targets (session-env, todos, file-history)
+      const autoCleanEntries = [
+        ...sessionEnvEntries,
+        ...todosEntries,
+        ...fileHistoryEntries,
+      ];
+
+      // Interactive selection targets (excluding auto-cleanup targets)
+      const selectableSessions = allSessions.filter(
+        (s) =>
+          s.type !== 'session-env' &&
+          s.type !== 'todos' &&
+          s.type !== 'file-history'
+      );
+
+      // Output summary
+      console.log();
+      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)})`);
+
+      if (options.verbose && !options.interactive) {
+        console.log();
+        // Exclude auto-cleanup targets from detailed list
+        for (const session of selectableSessions) {
+          console.log(
+            chalk.dim(`  ${session.toolName}: ${session.projectPath}`)
+          );
+        }
+      }
+
+      // Interactive mode: session selection (excluding auto-cleanup targets)
+      let sessionsToClean = allSessions;
+      if (options.interactive) {
+        if (selectableSessions.length === 0) {
+          // Only auto-cleanup targets exist
+          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<{
+            selected: OrphanedSession[];
+          }>([
+            {
+              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;
+          }
+
+          // Include selected sessions + auto-cleanup targets
+          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);
+
+      // Dry-run mode
+      if (options.dryRun) {
+        console.log();
+        logger.info(
+          chalk.yellow('Dry-run mode: No files will be deleted.')
+        );
+        console.log();
+
+        const dryRunFolders = sessionsToClean.filter(
+          (s) => s.type === 'session' || s.type === undefined
+        );
+        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(
+            `  ${chalk.red('Would delete:')} ${session.sessionPath} (${formatSize(session.size)})`
+          );
+        }
+
+        if (dryRunConfigs.length > 0) {
+          console.log();
+          console.log(
+            `  ${chalk.yellow('Would remove from ~/.claude.json:')}`
+          );
+          for (const config of dryRunConfigs) {
+            console.log(`    - ${config.projectPath}`);
+          }
+        }
+
+        // Auto-cleanup targets summary
+        const autoCleanParts: string[] = [];
+        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(
+            `  ${chalk.dim(`Would auto-delete: ${autoCleanParts.join(' + ')} (${formatSize(autoSize)})`)}`
+          );
+        }
+        return;
+      }
+
+      // Confirmation prompt (also in interactive mode)
+      if (!options.force) {
+        console.log();
+        const action = options.noTrash ? 'permanently delete' : 'move to trash';
+        const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            message: `${action} ${sessionsToClean.length} session(s) (${formatSize(cleanSize)})?`,
+            default: false,
+          },
+        ]);
+
+        if (!confirmed) {
+          logger.info('Cancelled.');
+          return;
+        }
+      }
+
+      // Execute cleanup
+      const cleanSpinner = ora('Cleaning orphaned sessions...').start();
+
+      const cleaner = new Cleaner();
+      const cleanResult = await cleaner.clean(sessionsToClean, {
+        dryRun: false,
+        useTrash: !options.noTrash,
+      });
+
+      cleanSpinner.stop();
+
+      // Output results
+      console.log();
+      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.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(chalk.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);
+    }
+  });

package/src/commands/config.ts

@@ -0,0 +1,144 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+
+import { logger } from '../utils/logger.js';
+import {
+  loadConfig,
+  addWatchPath,
+  removeWatchPath,
+  getWatchPaths,
+  getWatchDelay,
+  setWatchDelay,
+  getWatchDepth,
+  setWatchDepth,
+  resetConfig,
+} from '../utils/config.js';
+
+export const configCommand = new Command('config').description(
+  'Manage configuration'
+);
+
+const pathsCommand = new Command('paths').description('Manage watch paths');
+
+pathsCommand
+  .command('add <path>')
+  .description('Add a watch path')
+  .action((path: string) => {
+    addWatchPath(path);
+    logger.success(`Added: ${path}`);
+  });
+
+pathsCommand
+  .command('remove <path>')
+  .description('Remove a watch path')
+  .action((path: string) => {
+    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);
+
+const DEFAULT_DELAY_MINUTES = 5;
+const MAX_DELAY_MINUTES = 10;
+
+configCommand
+  .command('delay [minutes]')
+  .description(`Get or set watch delay in minutes (default: ${DEFAULT_DELAY_MINUTES}, max: ${MAX_DELAY_MINUTES})`)
+  .action((minutes?: string) => {
+    if (minutes === undefined) {
+      // Get current delay
+      const delay = getWatchDelay() ?? DEFAULT_DELAY_MINUTES;
+      console.log(`Watch delay: ${String(delay)} minute(s)`);
+    } else {
+      // Set delay
+      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_MINUTES) {
+        logger.warn(`Maximum delay is ${String(MAX_DELAY_MINUTES)} minutes. Setting to ${String(MAX_DELAY_MINUTES)}.`);
+        setWatchDelay(MAX_DELAY_MINUTES);
+        return;
+      }
+      setWatchDelay(value);
+      logger.success(`Watch delay set to ${String(value)} minute(s)`);
+    }
+  });
+
+const DEFAULT_DEPTH = 3;
+const MAX_DEPTH = 5;
+
+configCommand
+  .command('depth [level]')
+  .description('Get or set watch depth (default: 3, max: 5)')
+  .action((level?: string) => {
+    if (level === undefined) {
+      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: { force?: boolean }) => {
+    if (!options.force) {
+      const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([
+        {
+          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.');
+  });

package/src/commands/list.ts

@@ -0,0 +1,86 @@
+import { Command } from 'commander';
+import Table from 'cli-table3';
+import chalk from 'chalk';
+
+import { logger } from '../utils/logger.js';
+import { formatSize } from '../utils/size.js';
+import {
+  createAllScanners,
+  getAvailableScanners,
+} from '../scanners/index.js';
+import {
+  getClaudeProjectsDir,
+  getCursorWorkspaceDir,
+} from '../utils/paths.js';
+
+interface ListOptions {
+  verbose?: boolean;
+}
+
+export const listCommand = new Command('list')
+  .description('List detected AI coding tools and their data locations')
+  .option('-v, --verbose', 'Show detailed information')
+  .action(async (options: ListOptions) => {
+    const allScanners = createAllScanners();
+    const availableScanners = await getAvailableScanners(allScanners);
+
+    console.log();
+    console.log(chalk.bold('AI Coding Tools Status:'));
+    console.log();
+
+    const table = new Table({
+      head: [
+        chalk.cyan('Tool'),
+        chalk.cyan('Status'),
+        chalk.cyan('Data Location'),
+      ],
+      style: { head: [] },
+    });
+
+    const toolLocations: Record<string, string> = {
+      'claude-code': getClaudeProjectsDir(),
+      cursor: getCursorWorkspaceDir(),
+    };
+
+    for (const scanner of allScanners) {
+      const isAvailable = availableScanners.some((s) => s.name === scanner.name);
+      const status = isAvailable
+        ? chalk.green('Available')
+        : chalk.dim('Not found');
+      const location = toolLocations[scanner.name] || 'Unknown';
+
+      table.push([scanner.name, status, isAvailable ? location : chalk.dim(location)]);
+    }
+
+    console.log(table.toString());
+
+    // Additional info (verbose)
+    if (options.verbose && availableScanners.length > 0) {
+      console.log();
+      console.log(chalk.bold('Tool Details:'));
+      console.log();
+
+      for (const scanner of availableScanners) {
+        console.log(chalk.cyan(`${scanner.name}:`));
+
+        switch (scanner.name) {
+          case 'claude-code':
+            console.log('  Session format: Encoded project path directories');
+            console.log('  Path encoding: /path/to/project → -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();
+      }
+    }
+
+    // Summary
+    console.log(
+      chalk.dim(
+        `${availableScanners.length} of ${allScanners.length} tools detected on this system.`
+      )
+    );
+  });