@sooink/ai-session-tidy 0.1.1

package/src/core/cleaner.ts

@@ -0,0 +1,181 @@
+import { readFile, writeFile, mkdir, copyFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+import type { OrphanedSession } from '../scanners/types.js';
+import { moveToTrash, permanentDelete } from './trash.js';
+
+export interface CleanOptions {
+  dryRun: boolean;
+  useTrash?: boolean;
+}
+
+export interface CleanError {
+  sessionPath: string;
+  error: Error;
+}
+
+export interface CleanCountByType {
+  session: number;
+  sessionEnv: number;
+  todos: number;
+  fileHistory: number;
+}
+
+export interface CleanResult {
+  deletedCount: number;
+  deletedByType: CleanCountByType;
+  skippedCount: number;
+  alreadyGoneCount: number;
+  configEntriesRemoved: number;
+  totalSizeDeleted: number;
+  errors: CleanError[];
+  backupPath?: string;
+}
+
+interface ClaudeConfig {
+  projects?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+function getBackupDir(): string {
+  return join(homedir(), '.ai-session-tidy', 'backups');
+}
+
+export class Cleaner {
+  async clean(
+    sessions: OrphanedSession[],
+    options: CleanOptions
+  ): Promise<CleanResult> {
+    const result: CleanResult = {
+      deletedCount: 0,
+      deletedByType: {
+        session: 0,
+        sessionEnv: 0,
+        todos: 0,
+        fileHistory: 0,
+      },
+      skippedCount: 0,
+      alreadyGoneCount: 0,
+      configEntriesRemoved: 0,
+      totalSizeDeleted: 0,
+      errors: [],
+    };
+
+    const useTrash = options.useTrash ?? true;
+
+    // Separate session folders and config entries
+    const folderSessions = sessions.filter((s) => s.type !== 'config');
+    const configEntries = sessions.filter((s) => s.type === 'config');
+
+    // 1. Clean session folders/files
+    for (const session of folderSessions) {
+      if (options.dryRun) {
+        result.skippedCount++;
+        continue;
+      }
+
+      try {
+        const deleted = useTrash
+          ? await moveToTrash(session.sessionPath)
+          : await permanentDelete(session.sessionPath);
+
+        if (deleted) {
+          result.deletedCount++;
+          result.totalSizeDeleted += session.size;
+
+          // Count by type
+          switch (session.type) {
+            case 'session-env':
+              result.deletedByType.sessionEnv++;
+              break;
+            case 'todos':
+              result.deletedByType.todos++;
+              break;
+            case 'file-history':
+              result.deletedByType.fileHistory++;
+              break;
+            default:
+              result.deletedByType.session++;
+          }
+        } else {
+          // Already deleted path - not an error
+          result.alreadyGoneCount++;
+        }
+      } catch (error) {
+        result.errors.push({
+          sessionPath: session.sessionPath,
+          error: error instanceof Error ? error : new Error(String(error)),
+        });
+      }
+    }
+
+    // 2. Clean config entries
+    if (configEntries.length > 0 && !options.dryRun) {
+      try {
+        const configResult = await this.cleanConfigEntries(configEntries);
+        result.configEntriesRemoved = configResult.removed;
+        result.backupPath = configResult.backupPath;
+      } catch (error) {
+        result.errors.push({
+          sessionPath: configEntries[0].sessionPath,
+          error: error instanceof Error ? error : new Error(String(error)),
+        });
+      }
+    } else if (options.dryRun) {
+      result.skippedCount += configEntries.length;
+    }
+
+    return result;
+  }
+
+  /**
+   * Remove orphaned project entries from ~/.claude.json
+   */
+  private async cleanConfigEntries(
+    entries: OrphanedSession[]
+  ): Promise<{ removed: number; backupPath: string }> {
+    if (entries.length === 0) {
+      return { removed: 0, backupPath: '' };
+    }
+
+    const configPath = entries[0].sessionPath;
+    const projectPathsToRemove = new Set(entries.map((e) => e.projectPath));
+
+    // Create backup directory
+    const backupDir = getBackupDir();
+    if (!existsSync(backupDir)) {
+      await mkdir(backupDir, { recursive: true });
+    }
+
+    // Create backup file (with timestamp)
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = join(backupDir, `claude.json.${timestamp}.bak`);
+    await copyFile(configPath, backupPath);
+
+    // Read config file
+    const content = await readFile(configPath, 'utf-8');
+    const config: ClaudeConfig = JSON.parse(content);
+
+    if (!config.projects) {
+      return { removed: 0, backupPath };
+    }
+
+    // Remove orphaned project entries
+    let removedCount = 0;
+    for (const projectPath of projectPathsToRemove) {
+      if (projectPath in config.projects) {
+        delete config.projects[projectPath];
+        removedCount++;
+      }
+    }
+
+    // Save modified config
+    if (removedCount > 0) {
+      await writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+
+    return { removed: removedCount, backupPath };
+  }
+}

package/src/core/service.ts

@@ -0,0 +1,236 @@
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { readFile, writeFile, unlink, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+
+const SERVICE_LABEL = 'sooink.ai-session-tidy.watcher';
+const PLIST_FILENAME = `${SERVICE_LABEL}.plist`;
+
+export type ServiceStatus = 'running' | 'stopped' | 'not_installed';
+
+export interface ServiceInfo {
+  status: ServiceStatus;
+  pid?: number;
+  label: string;
+  plistPath: string;
+}
+
+function getPlistPath(): string {
+  return join(homedir(), 'Library', 'LaunchAgents', PLIST_FILENAME);
+}
+
+function getNodePath(): string {
+  // Get absolute path to node executable
+  return process.execPath;
+}
+
+function getScriptPath(): string {
+  // Get absolute path to the CLI script
+  const scriptPath = process.argv[1];
+  if (scriptPath && existsSync(scriptPath)) {
+    return scriptPath;
+  }
+  throw new Error('Could not determine script path');
+}
+
+function generatePlist(options: {
+  label: string;
+  nodePath: string;
+  scriptPath: string;
+  args: string[];
+}): string {
+  const allArgs = [options.nodePath, options.scriptPath, ...options.args];
+  const argsXml = allArgs.map((arg) => `    <string>${arg}</string>`).join('\n');
+
+  const home = homedir();
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${options.label}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${home}</string>
+  </dict>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(home, '.ai-session-tidy', 'watcher.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(home, '.ai-session-tidy', 'watcher.error.log')}</string>
+</dict>
+</plist>`;
+}
+
+export class ServiceManager {
+  private readonly plistPath: string;
+
+  constructor() {
+    this.plistPath = getPlistPath();
+  }
+
+  isSupported(): boolean {
+    return process.platform === 'darwin';
+  }
+
+  async install(): Promise<void> {
+    if (!this.isSupported()) {
+      throw new Error('Service management is only supported on macOS');
+    }
+
+    // Ensure LaunchAgents directory exists
+    const launchAgentsDir = dirname(this.plistPath);
+    if (!existsSync(launchAgentsDir)) {
+      await mkdir(launchAgentsDir, { recursive: true });
+    }
+
+    // Ensure log directory exists and clear old logs
+    const logDir = join(homedir(), '.ai-session-tidy');
+    if (!existsSync(logDir)) {
+      await mkdir(logDir, { recursive: true });
+    }
+
+    // Clear old log files
+    const stdoutPath = join(logDir, 'watcher.log');
+    const stderrPath = join(logDir, 'watcher.error.log');
+    await writeFile(stdoutPath, '', 'utf-8');
+    await writeFile(stderrPath, '', 'utf-8');
+
+    const plistContent = generatePlist({
+      label: SERVICE_LABEL,
+      nodePath: getNodePath(),
+      scriptPath: getScriptPath(),
+      args: ['watch', 'run'],
+    });
+
+    await writeFile(this.plistPath, plistContent, 'utf-8');
+  }
+
+  async uninstall(): Promise<void> {
+    if (existsSync(this.plistPath)) {
+      await unlink(this.plistPath);
+    }
+  }
+
+  async start(): Promise<void> {
+    if (!this.isSupported()) {
+      throw new Error('Service management is only supported on macOS');
+    }
+
+    if (!existsSync(this.plistPath)) {
+      throw new Error('Service not installed. Run "watch start" to install and start.');
+    }
+
+    try {
+      execSync(`launchctl load "${this.plistPath}"`, { stdio: 'pipe' });
+    } catch (error) {
+      // Already loaded is not an error
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes('already loaded')) {
+        throw error;
+      }
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.isSupported()) {
+      throw new Error('Service management is only supported on macOS');
+    }
+
+    if (!existsSync(this.plistPath)) {
+      return; // Nothing to stop
+    }
+
+    try {
+      execSync(`launchctl unload "${this.plistPath}"`, { stdio: 'pipe' });
+    } catch {
+      // Ignore errors when stopping (might not be running)
+    }
+  }
+
+  async status(): Promise<ServiceInfo> {
+    const info: ServiceInfo = {
+      status: 'not_installed',
+      label: SERVICE_LABEL,
+      plistPath: this.plistPath,
+    };
+
+    if (!this.isSupported()) {
+      return info;
+    }
+
+    if (!existsSync(this.plistPath)) {
+      return info;
+    }
+
+    try {
+      const output = execSync('launchctl list', { encoding: 'utf-8' });
+      const lines = output.split('\n');
+
+      for (const line of lines) {
+        if (line.includes(SERVICE_LABEL)) {
+          const parts = line.split(/\s+/);
+          const pid = parseInt(parts[0] ?? '', 10);
+
+          if (!isNaN(pid) && pid > 0) {
+            info.status = 'running';
+            info.pid = pid;
+          } else {
+            info.status = 'stopped';
+          }
+          return info;
+        }
+      }
+
+      // plist exists but not loaded
+      info.status = 'stopped';
+      return info;
+    } catch {
+      info.status = 'stopped';
+      return info;
+    }
+  }
+
+  async getLogs(lines: number = 50): Promise<{ stdout: string; stderr: string }> {
+    const logDir = join(homedir(), '.ai-session-tidy');
+    const stdoutPath = join(logDir, 'watcher.log');
+    const stderrPath = join(logDir, 'watcher.error.log');
+
+    let stdout = '';
+    let stderr = '';
+
+    try {
+      if (existsSync(stdoutPath)) {
+        const content = await readFile(stdoutPath, 'utf-8');
+        const logLines = content.split('\n');
+        stdout = logLines.slice(-lines).join('\n');
+      }
+    } catch {
+      // Ignore read errors
+    }
+
+    try {
+      if (existsSync(stderrPath)) {
+        const content = await readFile(stderrPath, 'utf-8');
+        const logLines = content.split('\n');
+        stderr = logLines.slice(-lines).join('\n');
+      }
+    } catch {
+      // Ignore read errors
+    }
+
+    return { stdout, stderr };
+  }
+}
+
+export const serviceManager = new ServiceManager();

package/src/core/trash.test.ts

@@ -0,0 +1,100 @@
+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 { moveToTrash, permanentDelete } from './trash.js';
+
+describe('moveToTrash', () => {
+  const testDir = join(tmpdir(), 'trashtest' + Date.now());
+
+  beforeEach(async () => {
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  it('moves file to trash', async () => {
+    const filePath = join(testDir, 'testfile.txt');
+    await writeFile(filePath, 'test content');
+
+    await moveToTrash(filePath);
+
+    // File should no longer exist
+    await expect(access(filePath)).rejects.toThrow();
+  });
+
+  it('moves directory to trash', async () => {
+    const dirPath = join(testDir, 'testdir');
+    await mkdir(dirPath);
+    await writeFile(join(dirPath, 'file.txt'), 'content');
+
+    await moveToTrash(dirPath);
+
+    // Directory should no longer exist
+    await expect(access(dirPath)).rejects.toThrow();
+  });
+
+  it('returns false for non-existent path (silent skip)', async () => {
+    const nonExistent = join(testDir, 'nonexistent12345');
+
+    const result = await moveToTrash(nonExistent);
+    expect(result).toBe(false);
+  });
+
+  it('returns true on successful file deletion', async () => {
+    const filePath = join(testDir, 'testfile2.txt');
+    await writeFile(filePath, 'test content');
+
+    const result = await moveToTrash(filePath);
+    expect(result).toBe(true);
+  });
+});
+
+describe('permanentDelete', () => {
+  const testDir = join(tmpdir(), 'delettest' + Date.now());
+
+  beforeEach(async () => {
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  it('permanently deletes file', async () => {
+    const filePath = join(testDir, 'todelete.txt');
+    await writeFile(filePath, 'to be deleted');
+
+    await permanentDelete(filePath);
+
+    await expect(access(filePath)).rejects.toThrow();
+  });
+
+  it('permanently deletes directory (recursive)', async () => {
+    const dirPath = join(testDir, 'todelete');
+    await mkdir(dirPath);
+    await writeFile(join(dirPath, 'file.txt'), 'content');
+
+    await permanentDelete(dirPath);
+
+    await expect(access(dirPath)).rejects.toThrow();
+  });
+
+  it('returns false for non-existent path (silent skip)', async () => {
+    const nonExistent = join(testDir, 'nonexistent12345');
+
+    const result = await permanentDelete(nonExistent);
+    expect(result).toBe(false);
+  });
+
+  it('returns true on successful file deletion', async () => {
+    const filePath = join(testDir, 'todelete2.txt');
+    await writeFile(filePath, 'to be deleted');
+
+    const result = await permanentDelete(filePath);
+    expect(result).toBe(true);
+  });
+});

package/src/core/trash.ts

@@ -0,0 +1,40 @@
+import { rm, access } from 'fs/promises';
+import trash from 'trash';
+
+/**
+ * Check if path exists
+ */
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Move file or directory to trash
+ * @returns true if deleted, false if already gone
+ */
+export async function moveToTrash(path: string): Promise<boolean> {
+  if (!(await pathExists(path))) {
+    return false; // Already deleted - silent skip
+  }
+
+  await trash(path);
+  return true;
+}
+
+/**
+ * Permanently delete file or directory
+ * @returns true if deleted, false if already gone
+ */
+export async function permanentDelete(path: string): Promise<boolean> {
+  if (!(await pathExists(path))) {
+    return false; // Already deleted - silent skip
+  }
+
+  await rm(path, { recursive: true, force: true });
+  return true;
+}