@sooink/ai-session-tidy 0.1.1 → 0.1.3

package/src/core/watcher.ts

@@ -1,6 +1,8 @@
 import { watch, FSWatcher } from 'chokidar';
 import { access } from 'fs/promises';
 
+import { IGNORED_SYSTEM_PATTERNS } from './constants.js';
+
 export interface WatchEvent {
   path: string;
   timestamp: Date;
@@ -13,6 +15,8 @@ export interface WatcherOptions {
   /** Debounce time to batch multiple delete events (default: 10 seconds) */
   debounceMs?: number;
   depth?: number;
+  /** User-defined paths to ignore */
+  ignorePaths?: string[];
   /** Callback to handle batched delete events */
   onDelete: (events: WatchEvent[]) => void;
 }
@@ -62,6 +66,8 @@ export class Watcher {
   private batchedEvents: WatchEvent[] = [];
   /** Debounce timer */
   private debounceTimer: NodeJS.Timeout | null = null;
+  /** Paths that errored (to avoid duplicate logs) */
+  private erroredPaths: Set<string> = new Set();
 
   constructor(options: WatcherOptions) {
     this.options = options;
@@ -71,10 +77,17 @@ export class Watcher {
   start(): void {
     if (this.watcher) return;
 
+    // Combine hardcoded patterns with user-defined ignore paths
+    const ignored: (RegExp | string)[] = [...IGNORED_SYSTEM_PATTERNS];
+    if (this.options.ignorePaths) {
+      ignored.push(...this.options.ignorePaths);
+    }
+
     this.watcher = watch(this.options.watchPaths, {
       ignoreInitial: true,
       persistent: true,
       depth: this.options.depth ?? 3,
+      ignored,
     });
 
     this.watcher.on('unlinkDir', (path) => {
@@ -84,6 +97,15 @@ export class Watcher {
     this.watcher.on('addDir', (path) => {
       this.handleRecovery(path);
     });
+
+    // Handle errors gracefully - log and continue watching
+    this.watcher.on('error', (error) => {
+      const pathInfo = (error as NodeJS.ErrnoException & { path?: string }).path;
+      if (pathInfo && !this.erroredPaths.has(pathInfo)) {
+        this.erroredPaths.add(pathInfo);
+        console.error(`[watch] Cannot watch: ${pathInfo} (${(error as NodeJS.ErrnoException).code})`);
+      }
+    });
   }
 
   stop(): void {

package/src/utils/config.ts

@@ -28,11 +28,11 @@ export function getAppVersion(): string {
 }
 
 export interface Config {
-  version?: string; // app version that last saved this config
-  configVersion?: string; // config schema version
+  configVersion?: string; // config schema version for migration
   watchPaths?: string[];
   watchDelay?: number; // minutes
   watchDepth?: number; // folder depth (default: 3, max: 5)
+  ignorePaths?: string[]; // paths to ignore from watching
 }
 
 function getConfigPath(): string {
@@ -62,10 +62,12 @@ export function saveConfig(config: Config): void {
     mkdirSync(configDir, { recursive: true });
   }
 
+  // Remove deprecated 'version' field if present
+  const { version: _removed, ...cleanConfig } = config as Config & { version?: string };
+
   const configWithVersion: Config = {
-    version: getAppVersion(),
     configVersion: CONFIG_VERSION,
-    ...config,
+    ...cleanConfig,
   };
 
   writeFileSync(configPath, JSON.stringify(configWithVersion, null, 2), 'utf-8');
@@ -130,3 +132,31 @@ export function setWatchDepth(depth: number): void {
 export function resetConfig(): void {
   saveConfig({});
 }
+
+export function getIgnorePaths(): string[] | undefined {
+  const config = loadConfig();
+  return config.ignorePaths;
+}
+
+export function addIgnorePath(path: string): void {
+  const config = loadConfig();
+  const resolved = resolve(path.replace(/^~/, homedir()));
+  const paths = config.ignorePaths ?? [];
+  if (!paths.includes(resolved)) {
+    paths.push(resolved);
+    config.ignorePaths = paths;
+    saveConfig(config);
+  }
+}
+
+export function removeIgnorePath(path: string): boolean {
+  const config = loadConfig();
+  const resolved = resolve(path.replace(/^~/, homedir()));
+  const paths = config.ignorePaths ?? [];
+  const index = paths.indexOf(resolved);
+  if (index === -1) return false;
+  paths.splice(index, 1);
+  config.ignorePaths = paths;
+  saveConfig(config);
+  return true;
+}

package/src/utils/paths.ts

@@ -1,3 +1,4 @@
+import { existsSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 
@@ -14,13 +15,45 @@ export function encodePath(path: string): string {
 
 /**
  * Decode Claude Code encoded path to Unix path
- * -home-user-project → /home/user/project
+ * Handles hyphenated folder names by checking filesystem
+ *
+ * -Users-kory-my-project → /Users/kory/my-project (if exists)
+ * -Users-kory-my-project → /Users/kory/my/project (fallback)
  */
 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, '/');
+
+  // Split by dash (remove leading dash first)
+  const parts = encoded.slice(1).split('-');
+
+  // Try to reconstruct path by checking filesystem
+  return reconstructPath(parts, '');
+}
+
+/**
+ * Recursively reconstruct path by trying different combinations
+ */
+function reconstructPath(parts: string[], currentPath: string): string {
+  if (parts.length === 0) return currentPath;
+
+  // Try combining segments (longest first to prefer hyphenated names)
+  for (let len = parts.length; len >= 1; len--) {
+    const segment = parts.slice(0, len).join('-');
+    const testPath = currentPath + '/' + segment;
+
+    if (existsSync(testPath)) {
+      // Found existing path, continue with remaining parts
+      const result = reconstructPath(parts.slice(len), testPath);
+      // Verify the final path exists (or is the best we can do)
+      if (existsSync(result) || parts.slice(len).length === 0) {
+        return result;
+      }
+    }
+  }
+
+  // No existing path found, use simple decode for remaining parts
+  return currentPath + '/' + parts.join('/');
 }
 
 /**