@sooink/ai-session-tidy 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sooink/ai-session-tidy",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "CLI tool that detects and cleans orphaned session data from AI coding tools",
   "type": "module",
   "bin": {
@@ -51,4 +51,4 @@
     "typescript-eslint": "^8.21.0",
     "vitest": "^3.0.4"
   }
-}
+}

package/src/commands/clean.ts

@@ -31,9 +31,33 @@ function formatSessionChoice(session: OrphanedSession): string {
     ? 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}`;
+  const size = isConfig ? '' : ` ${chalk.dim(`(${formatSize(session.size)})`)}`;
+  const path = chalk.dim(`→ ${tildify(session.projectPath)}`);
+  return `${toolTag} ${name}${size}\n      ${path}`;
+}
+
+interface GroupChoice {
+  type: 'session-env' | 'todos' | 'file-history';
+  sessions: OrphanedSession[];
+  totalSize: number;
+}
+
+function formatGroupChoice(group: GroupChoice): string {
+  const labels: Record<string, string> = {
+    'session-env': 'empty session-env folder',
+    'todos': 'orphaned todos file',
+    'file-history': 'orphaned file-history folder',
+  };
+  const colors: Record<string, (s: string) => string> = {
+    'session-env': chalk.green,
+    'todos': chalk.magenta,
+    'file-history': chalk.blue,
+  };
+  const label = labels[group.type] || group.type;
+  const count = group.sessions.length;
+  const plural = count > 1 ? 's' : '';
+  const color = colors[group.type] || chalk.white;
+  return `${color(`[${group.type}]`)} ${chalk.white(`${count} ${label}${plural}`)} ${chalk.dim(`(${formatSize(group.totalSize)})`)}`;
 }
 
 export const cleanCommand = new Command('clean')
@@ -67,7 +91,7 @@ export const cleanCommand = new Command('clean')
         return;
       }
 
-      // Separate session folders, config entries, and auto-cleanup targets
+      // Separate by type
       const folderSessions = allSessions.filter(
         (s) => s.type === 'session' || s.type === undefined
       );
@@ -80,21 +104,38 @@ export const cleanCommand = new Command('clean')
         (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(
+      // Individual selection targets (session folders and config entries)
+      const individualSessions = allSessions.filter(
         (s) =>
           s.type !== 'session-env' &&
           s.type !== 'todos' &&
           s.type !== 'file-history'
       );
 
+      // Group selection targets (session-env, todos, file-history)
+      const groupChoices: GroupChoice[] = [];
+      if (sessionEnvEntries.length > 0) {
+        groupChoices.push({
+          type: 'session-env',
+          sessions: sessionEnvEntries,
+          totalSize: sessionEnvEntries.reduce((sum, s) => sum + s.size, 0),
+        });
+      }
+      if (todosEntries.length > 0) {
+        groupChoices.push({
+          type: 'todos',
+          sessions: todosEntries,
+          totalSize: todosEntries.reduce((sum, s) => sum + s.size, 0),
+        });
+      }
+      if (fileHistoryEntries.length > 0) {
+        groupChoices.push({
+          type: 'file-history',
+          sessions: fileHistoryEntries,
+          totalSize: fileHistoryEntries.reduce((sum, s) => sum + s.size, 0),
+        });
+      }
+
       // Output summary
       console.log();
       const parts: string[] = [];
@@ -117,68 +158,108 @@ export const cleanCommand = new Command('clean')
 
       if (options.verbose && !options.interactive) {
         console.log();
-        // Exclude auto-cleanup targets from detailed list
-        for (const session of selectableSessions) {
+        for (const session of individualSessions) {
           console.log(
-            chalk.dim(`  ${session.toolName}: ${session.projectPath}`)
+            chalk.dim(`  ${session.toolName}: ${tildify(session.projectPath)}`)
           );
         }
       }
 
-      // Interactive mode: session selection (excluding auto-cleanup targets)
+      // Interactive mode: session selection
       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;
+        if (!process.stdout.isTTY) {
+          logger.error('Interactive mode requires a TTY. Omit -i or use -f to skip confirmation.');
+          return;
+        }
+        // Build choices: individual sessions + group choices
+        const choices: Array<{
+          name: string;
+          value: { type: 'individual'; session: OrphanedSession } | { type: 'group'; group: GroupChoice };
+          checked: boolean;
+        }> = [];
+
+        // Add individual sessions
+        for (const session of individualSessions) {
+          choices.push({
+            name: formatSessionChoice(session),
+            value: { type: 'individual', session },
+            checked: false,
+          });
+        }
+
+        // Add group choices
+        for (const group of groupChoices) {
+          choices.push({
+            name: formatGroupChoice(group),
+            value: { type: 'group', group },
+            checked: false,
+          });
+        }
+
+        if (choices.length === 0) {
+          logger.info('No selectable sessions found.');
+          return;
+        }
+
+        console.log();
+        const { selected } = await inquirer.prompt<{
+          selected: Array<{ type: 'individual'; session: OrphanedSession } | { type: 'group'; group: GroupChoice }>;
+        }>([
+          {
+            type: 'checkbox',
+            name: 'selected',
+            message: 'Select items to delete:',
+            choices,
+            pageSize: 15,
+            loop: false,
+          },
+        ]);
+
+        if (selected.length === 0) {
+          logger.info('No items selected. Cancelled.');
+          return;
+        }
+
+        // Clear inquirer's multi-line output (approximately N+1 lines for N selected items)
+        if (process.stdout.isTTY) {
+          const linesToClear = selected.length + 1;
+          for (let i = 0; i < linesToClear; i++) {
+            process.stdout.write('\x1B[1A\x1B[2K');
           }
+        }
 
-          // 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)})`
-            );
+        // Display selected items in a clean list
+        console.log(chalk.green('✔') + ' ' + chalk.bold('Selected items:'));
+        for (const item of selected) {
+          if (item.type === 'individual') {
+            const s = item.session;
+            const tag = s.type === 'config'
+              ? chalk.yellow('[config]')
+              : chalk.cyan(`[${s.toolName}]`);
+            const size = s.type === 'config' ? '' : ` ${chalk.dim(`(${formatSize(s.size)})`)}`;
+            console.log(`  ${tag} ${basename(s.projectPath)}${size}`);
+            console.log(`      ${chalk.dim(`→ ${tildify(s.projectPath)}`)}`);
+          } else {
+            console.log(`  ${formatGroupChoice(item.group)}`);
           }
-          if (autoCleanEntries.length > 0) {
-            const autoSize = autoCleanEntries.reduce((sum, s) => sum + s.size, 0);
-            logger.info(
-              `+ ${autoCleanEntries.length} auto-cleanup target(s) (${formatSize(autoSize)})`
-            );
+        }
+
+        // Flatten selected items
+        sessionsToClean = [];
+        for (const item of selected) {
+          if (item.type === 'individual') {
+            sessionsToClean.push(item.session);
+          } else {
+            sessionsToClean.push(...item.group.sessions);
           }
         }
+
+        const selectedSize = sessionsToClean.reduce((sum, s) => sum + s.size, 0);
+        console.log();
+        logger.info(
+          `Selected: ${sessionsToClean.length} item(s) (${formatSize(selectedSize)})`
+        );
       }
 
       const cleanSize = sessionsToClean.reduce((sum, s) => sum + s.size, 0);
@@ -205,7 +286,7 @@ export const cleanCommand = new Command('clean')
 
         for (const session of dryRunFolders) {
           console.log(
-            `  ${chalk.red('Would delete:')} ${session.sessionPath} (${formatSize(session.size)})`
+            `  ${chalk.red('Would delete:')} ${tildify(session.sessionPath)} (${formatSize(session.size)})`
           );
         }
 
@@ -215,29 +296,27 @@ export const cleanCommand = new Command('clean')
             `  ${chalk.yellow('Would remove from ~/.claude.json:')}`
           );
           for (const config of dryRunConfigs) {
-            console.log(`    - ${config.projectPath}`);
+            console.log(`    - ${tildify(config.projectPath)}`);
           }
         }
 
-        // Auto-cleanup targets summary
-        const autoCleanParts: string[] = [];
+        // Group items summary
         if (dryRunEnvs.length > 0) {
-          autoCleanParts.push(`${dryRunEnvs.length} session-env`);
+          console.log();
+          console.log(
+            `  ${chalk.green('Would delete:')} ${dryRunEnvs.length} session-env folder(s)`
+          );
         }
         if (dryRunTodos.length > 0) {
-          autoCleanParts.push(`${dryRunTodos.length} todos`);
+          console.log();
+          console.log(
+            `  ${chalk.magenta('Would delete:')} ${dryRunTodos.length} todos file(s) (${formatSize(dryRunTodos.reduce((sum, s) => sum + s.size, 0))})`
+          );
         }
         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)})`)}`
+            `  ${chalk.blue('Would delete:')} ${dryRunHistories.length} file-history folder(s) (${formatSize(dryRunHistories.reduce((sum, s) => sum + s.size, 0))})`
           );
         }
         return;
@@ -245,6 +324,10 @@ export const cleanCommand = new Command('clean')
 
       // Confirmation prompt (also in interactive mode)
       if (!options.force) {
+        if (!process.stdout.isTTY) {
+          logger.error('Confirmation requires a TTY. Use -f to skip confirmation.');
+          return;
+        }
         console.log();
         const action = options.noTrash ? 'permanently delete' : 'move to trash';
         const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([
@@ -321,7 +404,7 @@ export const cleanCommand = new Command('clean')
         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}`));
+            console.log(chalk.red(`  ${tildify(err.sessionPath)}: ${err.error.message}`));
           }
         }
       }

package/src/commands/config.ts

@@ -1,7 +1,10 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
+import { homedir } from 'os';
+import { resolve } from 'path';
 
 import { logger } from '../utils/logger.js';
+import { tildify } from '../utils/paths.js';
 import {
   loadConfig,
   addWatchPath,
@@ -12,23 +15,37 @@ import {
   getWatchDepth,
   setWatchDepth,
   resetConfig,
+  addIgnorePath,
+  removeIgnorePath,
+  getIgnorePaths,
 } from '../utils/config.js';
 
 export const configCommand = new Command('config').description(
   'Manage configuration'
 );
 
-const pathsCommand = new Command('paths').description('Manage watch paths');
+const pathCommand = new Command('path').description('Manage watch paths');
 
-pathsCommand
+pathCommand
   .command('add <path>')
   .description('Add a watch path')
   .action((path: string) => {
+    const resolved = resolve(path.replace(/^~/, homedir()));
+    const home = homedir();
+
+    // Warn if adding home directory or its parent
+    if (resolved === home || home.startsWith(resolved + '/')) {
+      logger.warn('Warning: Watching home directory is not recommended.');
+      logger.warn('Many system folders will be excluded automatically.');
+      logger.warn('Consider adding specific project folders instead.');
+      console.log();
+    }
+
     addWatchPath(path);
     logger.success(`Added: ${path}`);
   });
 
-pathsCommand
+pathCommand
   .command('remove <path>')
   .description('Remove a watch path')
   .action((path: string) => {
@@ -40,7 +57,7 @@ pathsCommand
     }
   });
 
-pathsCommand
+pathCommand
   .command('list')
   .description('List watch paths')
   .action(() => {
@@ -51,11 +68,50 @@ pathsCommand
     }
     console.log();
     for (const p of paths) {
-      console.log(`  ${p}`);
+      console.log(`  ${tildify(p)}`);
     }
   });
 
-configCommand.addCommand(pathsCommand);
+configCommand.addCommand(pathCommand);
+
+const ignoreCommand = new Command('ignore').description('Manage ignore paths');
+
+ignoreCommand
+  .command('add <path>')
+  .description('Add a path to ignore from watching')
+  .action((path: string) => {
+    addIgnorePath(path);
+    logger.success(`Added to ignore: ${path}`);
+  });
+
+ignoreCommand
+  .command('remove <path>')
+  .description('Remove a path from ignore list')
+  .action((path: string) => {
+    const removed = removeIgnorePath(path);
+    if (removed) {
+      logger.success(`Removed from ignore: ${path}`);
+    } else {
+      logger.warn(`Path not found: ${path}`);
+    }
+  });
+
+ignoreCommand
+  .command('list')
+  .description('List ignored paths')
+  .action(() => {
+    const paths = getIgnorePaths();
+    if (!paths || paths.length === 0) {
+      logger.info('No ignore paths configured.');
+      return;
+    }
+    console.log();
+    for (const p of paths) {
+      console.log(`  ${tildify(p)}`);
+    }
+  });
+
+configCommand.addCommand(ignoreCommand);
 
 const DEFAULT_DELAY_MINUTES = 5;
 const MAX_DELAY_MINUTES = 10;
@@ -124,6 +180,10 @@ configCommand
   .option('-f, --force', 'Skip confirmation prompt')
   .action(async (options: { force?: boolean }) => {
     if (!options.force) {
+      if (!process.stdout.isTTY) {
+        logger.error('Confirmation requires a TTY. Use -f to skip confirmation.');
+        return;
+      }
       const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([
         {
           type: 'confirm',

package/src/commands/scan.ts

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 
 import { logger } from '../utils/logger.js';
 import { formatSize } from '../utils/size.js';
+import { tildify } from '../utils/paths.js';
 import {
   createAllScanners,
   getAvailableScanners,
@@ -163,7 +164,7 @@ function outputTable(results: ScanResult[], verbose?: boolean): void {
         console.log(
           `  ${chalk.cyan(`[${session.toolName}]`)} ${chalk.white(projectName)} ${chalk.dim(`(${formatSize(session.size)})`)}`
         );
-        console.log(`    ${chalk.dim('→')} ${session.projectPath}`);
+        console.log(`    ${chalk.dim('→')} ${tildify(session.projectPath)}`);
         console.log(`    ${chalk.dim('Modified:')} ${session.lastModified.toLocaleDateString()}`);
         console.log();
       }
@@ -180,7 +181,7 @@ function outputTable(results: ScanResult[], verbose?: boolean): void {
         console.log(
           `  ${chalk.yellow('[config]')} ${chalk.white(projectName)}`
         );
-        console.log(`    ${chalk.dim('→')} ${entry.projectPath}`);
+        console.log(`    ${chalk.dim('→')} ${tildify(entry.projectPath)}`);
         if (entry.configStats?.lastCost) {
           const cost = `$${entry.configStats.lastCost.toFixed(2)}`;
           const inTokens = formatTokens(entry.configStats.lastTotalInputTokens);
@@ -191,6 +192,54 @@ function outputTable(results: ScanResult[], verbose?: boolean): void {
       }
     }
 
+    // Session Env (empty folders)
+    if (sessionEnvEntries.length > 0) {
+      console.log();
+      console.log(chalk.bold('Empty Session Env Folders:'));
+      console.log();
+
+      for (const entry of sessionEnvEntries) {
+        const folderName = entry.sessionPath.split('/').pop() || entry.sessionPath;
+        console.log(
+          `  ${chalk.green('[session-env]')} ${chalk.white(folderName)} ${chalk.dim('(empty)')}`
+        );
+        console.log(`    ${chalk.dim('→')} ${tildify(entry.sessionPath)}`);
+        console.log();
+      }
+    }
+
+    // Todos
+    if (todosEntries.length > 0) {
+      console.log();
+      console.log(chalk.bold('Orphaned Todos:'));
+      console.log();
+
+      for (const entry of todosEntries) {
+        const fileName = entry.sessionPath.split('/').pop() || entry.sessionPath;
+        console.log(
+          `  ${chalk.magenta('[todos]')} ${chalk.white(fileName)} ${chalk.dim(`(${formatSize(entry.size)})`)}`
+        );
+        console.log(`    ${chalk.dim('→')} ${tildify(entry.sessionPath)}`);
+        console.log();
+      }
+    }
+
+    // File history
+    if (fileHistoryEntries.length > 0) {
+      console.log();
+      console.log(chalk.bold('Orphaned File History:'));
+      console.log();
+
+      for (const entry of fileHistoryEntries) {
+        const folderName = entry.sessionPath.split('/').pop() || entry.sessionPath;
+        console.log(
+          `  ${chalk.blue('[file-history]')} ${chalk.white(folderName)} ${chalk.dim(`(${formatSize(entry.size)})`)}`
+        );
+        console.log(`    ${chalk.dim('→')} ${tildify(entry.sessionPath)}`);
+        console.log();
+      }
+    }
+
   }
 
   console.log();

package/src/commands/watch.ts

@@ -6,7 +6,8 @@ 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 { tildify } from '../utils/paths.js';
+import { getWatchPaths as getConfigWatchPaths, setWatchPaths, getWatchDelay, getWatchDepth, getIgnorePaths } from '../utils/config.js';
 import {
   createAllScanners,
   getAvailableScanners,
@@ -140,7 +141,7 @@ const statusCommand = new Command('status')
       if (status.pid) {
         console.log(`PID:    ${status.pid}`);
       }
-      console.log(`Plist:  ${status.plistPath}`);
+      console.log(`Plist:  ${tildify(status.plistPath)}`);
       console.log();
 
       if (options.logs) {
@@ -233,7 +234,7 @@ async function runWatcher(options: RunOptions): Promise<void> {
 
   if (validPaths.length < watchPaths.length) {
     const invalidPaths = watchPaths.filter((p) => !existsSync(p));
-    logger.warn(`Skipping non-existent paths: ${invalidPaths.join(', ')}`);
+    logger.warn(`Skipping non-existent paths: ${invalidPaths.map(tildify).join(', ')}`);
   }
 
   // Check scanners
@@ -250,7 +251,7 @@ async function runWatcher(options: RunOptions): Promise<void> {
   logger.info(
     `Watching for project deletions (${availableScanners.map((s) => s.name).join(', ')})`
   );
-  logger.info(`Watch paths: ${validPaths.join(', ')}`);
+  logger.info(`Watch paths: ${validPaths.map(tildify).join(', ')}`);
   logger.info(`Cleanup delay: ${String(delayMinutes)} minute(s)`);
   logger.info(`Watch depth: ${String(depth)}`);
   if (process.stdout.isTTY) {
@@ -264,15 +265,16 @@ async function runWatcher(options: RunOptions): Promise<void> {
     watchPaths: validPaths,
     delayMs,
     depth,
+    ignorePaths: getIgnorePaths(),
     onDelete: async (events) => {
       // Log batch events
       if (events.length === 1) {
-        logger.info(`Detected deletion: ${events[0].path}`);
+        logger.info(`Detected deletion: ${tildify(events[0].path)}`);
       } else {
         logger.info(`Detected ${events.length} deletions (debounced)`);
         if (options.verbose) {
           for (const event of events) {
-            logger.debug(`  - ${event.path}`);
+            logger.debug(`  - ${tildify(event.path)}`);
           }
         }
       }

package/src/core/constants.ts

@@ -0,0 +1,22 @@
+/**
+ * System folders to ignore when watching (macOS)
+ * These are hidden folders that should never be monitored
+ */
+export const IGNORED_SYSTEM_PATTERNS: RegExp[] = [
+  // All hidden folders (starting with .)
+  /(^|[/\\])\../,
+
+  // macOS user folders (not project directories)
+  /\/Library(\/|$)/,
+  /\/Applications(\/|$)/,
+  /\/Music(\/|$)/,
+  /\/Movies(\/|$)/,
+  /\/Pictures(\/|$)/,
+  /\/Downloads(\/|$)/,
+  /\/Documents(\/|$)/,
+  /\/Desktop(\/|$)/,
+  /\/Public(\/|$)/,
+
+  // Development folders
+  /node_modules(\/|$)/,
+];

package/src/core/service.ts

@@ -131,6 +131,17 @@ export class ServiceManager {
       throw new Error('Service not installed. Run "watch start" to install and start.');
     }
 
+    // Clear old log files before starting
+    const logDir = join(homedir(), '.ai-session-tidy');
+    const stdoutPath = join(logDir, 'watcher.log');
+    const stderrPath = join(logDir, 'watcher.error.log');
+    if (existsSync(stdoutPath)) {
+      await writeFile(stdoutPath, '', 'utf-8');
+    }
+    if (existsSync(stderrPath)) {
+      await writeFile(stderrPath, '', 'utf-8');
+    }
+
     try {
       execSync(`launchctl load "${this.plistPath}"`, { stdio: 'pipe' });
     } catch (error) {