tidyf 1.0.2 → 1.1.0

package/src/commands/undo.ts

@@ -0,0 +1,139 @@
+/**
+ * Undo command - revert file organization operations
+ */
+
+import * as p from "@clack/prompts";
+import { existsSync } from "fs";
+import { rename, mkdir } from "fs/promises";
+import { dirname } from "path";
+import color from "picocolors";
+import { initGlobalConfig } from "../lib/config.ts";
+import { cleanup } from "../lib/opencode.ts";
+import {
+  deleteHistoryEntry,
+  getHistoryEntry,
+  getRecentHistory,
+  type HistoryEntry,
+} from "../lib/history.ts";
+
+/**
+ * Select a history entry to undo
+ */
+async function selectHistoryEntry(): Promise<HistoryEntry | null> {
+  const history = getRecentHistory();
+
+  if (history.length === 0) {
+    p.log.warn("No history to undo");
+    return null;
+  }
+
+  const options = history.map((entry) => ({
+    value: entry.id,
+    label: `${new Date(entry.timestamp).toLocaleString()}`,
+    hint: `${entry.moves.length} files moved`,
+  }));
+
+  const selectedId = await p.select({
+    message: "Which operation to undo?",
+    options,
+  });
+
+  if (p.isCancel(selectedId)) {
+    return null;
+  }
+
+  return getHistoryEntry(selectedId as string);
+}
+
+/**
+ * Undo a file move
+ */
+async function undoMove(source: string, destination: string): Promise<boolean> {
+  try {
+    // Ensure source directory exists (in case it was deleted)
+    await mkdir(dirname(source), { recursive: true });
+
+    await rename(destination, source);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Main undo command
+ */
+export async function undoCommand(): Promise<void> {
+  p.intro(color.bgRed(color.black(" tidyf undo ")));
+
+  initGlobalConfig();
+
+  const entry = await selectHistoryEntry();
+
+  if (!entry) {
+    p.outro(color.yellow("Nothing to undo"));
+    cleanup();
+    return;
+  }
+
+  console.log();
+  p.log.info(color.bold("Operation details:"));
+  p.log.message(`  Timestamp: ${new Date(entry.timestamp).toLocaleString()}`);
+  p.log.message(`  Source: ${entry.source}`);
+  p.log.message(`  Target: ${entry.target}`);
+  p.log.message(`  Files moved: ${entry.moves.length}`);
+
+  const confirm = await p.confirm({
+    message: `Undo this operation? This will move ${entry.moves.length} files back to ${entry.source}`,
+    initialValue: false,
+  });
+
+  if (p.isCancel(confirm) || !confirm) {
+    p.outro(color.yellow("Cancelled"));
+    cleanup();
+    return;
+  }
+
+  const s = p.spinner();
+  s.start("Undoing file moves...");
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const move of entry.moves) {
+    const destExists = existsSync(move.destination);
+
+    if (!destExists) {
+      p.log.warn(`  Skipped: ${move.destination} (already moved/deleted)`);
+      failCount++;
+      continue;
+    }
+
+    if (await undoMove(move.source, move.destination)) {
+      successCount++;
+    } else {
+      failCount++;
+    }
+  }
+
+  s.stop("Undo complete");
+
+  p.log.success(`\nMoved ${successCount} files back to ${color.cyan(entry.source)}`);
+
+  if (failCount > 0) {
+    p.log.warn(`${failCount} files could not be moved`);
+  }
+
+  const deleteFromHistory = await p.confirm({
+    message: "Remove this operation from history?",
+    initialValue: true,
+  });
+
+  if (p.isCancel(deleteFromHistory) || deleteFromHistory) {
+    deleteHistoryEntry(entry.id);
+    p.log.success("Removed from history");
+  }
+
+  p.outro(color.green("Done!"));
+  cleanup();
+}

package/src/commands/watch.ts

@@ -9,9 +9,11 @@ import {
   initGlobalConfig,
   parseModelString,
   resolveConfig,
+  resolveConfigWithProfile,
 } from "../lib/config.ts";
 import { analyzeFiles, cleanup } from "../lib/opencode.ts";
-import { getFileMetadata } from "../lib/scanner.ts";
+import { listProfiles, profileExists } from "../lib/profiles.ts";
+import { getFileMetadata, scanFolderStructure } from "../lib/scanner.ts";
 import { createWatcher, type FileWatcher } from "../lib/watcher.ts";
 import type {
   FileMetadata,
@@ -23,6 +25,41 @@ import type {
 import { formatFileSize, moveFile } from "../utils/files.ts";
 import { getCategoryIcon, getFileIcon } from "../utils/icons.ts";
 
+// Folder cache for watch mode to avoid re-scanning on every file event
+let folderCache: string[] = [];
+let lastFolderScan = 0;
+const FOLDER_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Get existing folders with caching
+ */
+async function getExistingFolders(
+  targetPath: string,
+  ignore: string[] = [],
+): Promise<string[]> {
+  const now = Date.now();
+  if (now - lastFolderScan > FOLDER_CACHE_TTL) {
+    try {
+      folderCache = await scanFolderStructure(targetPath, {
+        maxDepth: 3,
+        includeEmpty: false,
+        ignore,
+      });
+      lastFolderScan = now;
+    } catch {
+      // Target directory might not exist yet - use cached or empty
+    }
+  }
+  return folderCache;
+}
+
+/**
+ * Invalidate folder cache (call after successful file moves)
+ */
+function invalidateFolderCache(): void {
+  lastFolderScan = 0;
+}
+
 /**
  * Display a proposal briefly for watch mode
  */
@@ -57,6 +94,11 @@ async function executeProposalsSilent(
     }
   }
 
+  // Invalidate folder cache since new folders may have been created
+  if (success > 0) {
+    invalidateFolderCache();
+  }
+
   return { success, failed };
 }
 
@@ -112,8 +154,26 @@ export async function watchCommand(options: WatchOptions): Promise<void> {
   // Initialize global config if needed
   initGlobalConfig();
 
-  // Resolve configuration
-  const config = resolveConfig();
+  // Validate and resolve profile if specified
+  if (options.profile) {
+    if (!profileExists(options.profile)) {
+      p.log.error(`Profile "${options.profile}" not found`);
+      const profiles = listProfiles();
+      if (profiles.length > 0) {
+        p.log.info("Available profiles:");
+        profiles.forEach((pr) => p.log.message(`  - ${pr.name}`));
+      }
+      p.outro("Canceled");
+      cleanup();
+      process.exit(1);
+    }
+    p.log.info(`Profile: ${color.cyan(options.profile)}`);
+  }
+
+  // Resolve configuration (with profile if specified)
+  const config = options.profile
+    ? resolveConfigWithProfile(options.profile)
+    : resolveConfig();
 
   // Determine paths to watch
   let watchPaths: string[];
@@ -207,10 +267,13 @@ export async function watchCommand(options: WatchOptions): Promise<void> {
 
     let proposal: OrganizationProposal;
     try {
+      const existingFolders = await getExistingFolders(targetPath, config.ignore);
       proposal = await analyzeFiles({
         files,
         targetDir: targetPath,
         model: parseModelString(options.model),
+        existingFolders,
+        profileName: options.profile,
       });
       s.stop("Analysis complete");
     } catch (error: any) {
@@ -276,10 +339,13 @@ export async function watchCommand(options: WatchOptions): Promise<void> {
         s.start("Analyzing queued files...");
 
         try {
+          const existingFolders = await getExistingFolders(targetPath, config.ignore);
           const proposal = await analyzeFiles({
             files: reviewQueue,
             targetDir: targetPath,
             model: parseModelString(options.model),
+            existingFolders,
+            profileName: options.profile,
           });
           s.stop("Analysis complete");
 

package/src/lib/config.ts

@@ -8,6 +8,12 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import type { TidyConfig, ModelSelection } from "../types/config.ts";
+import {
+	profileExists,
+	readProfile,
+	readProfileRules,
+	getProfileConfigFields,
+} from "./profiles.ts";
 
 const CONFIG_DIR = ".tidy";
 const SETTINGS_FILE = "settings.json";
@@ -94,6 +100,20 @@ You are an AI assistant that organizes files from a download folder. Analyze eac
 5. Installer files go to Applications/Installers
 6. Compressed files stay as Archives unless clearly part of another category
 
+## Existing Folder Preferences
+
+When existing folders are provided in the prompt:
+
+1. **STRONGLY PREFER existing folders** - Use them when the file fits the category
+2. **Match naming conventions** - If "Screenshots" exists, don't create "Screen Captures"
+3. **Extend existing hierarchy** - OK to create subfolders under existing folders
+4. **Only create new top-level folders** when no existing category applies
+
+Examples:
+- If "Images/Screenshots" exists, use it for screenshot files
+- If "Documents/Work" exists but no "Reports" subfolder, create "Documents/Work/Reports"
+- If only "Documents" exists, prefer "Documents/Receipts" over top-level "Receipts"
+
 ## Output Format
 
 Return JSON with this exact structure:
@@ -333,3 +353,66 @@ export function getDefaultConfig(): TidyConfig {
 export function getDefaultRules(): string {
   return DEFAULT_RULES;
 }
+
+/**
+ * Resolve the effective configuration with profile support
+ * Resolution order: defaults → global → profile → local
+ */
+export function resolveConfigWithProfile(
+	profileName?: string,
+	basePath: string = process.cwd(),
+): TidyConfig {
+	// Start with defaults
+	const config: TidyConfig = { ...DEFAULT_CONFIG };
+
+	// Merge global config
+	const globalConfig = readConfig(getGlobalConfigPath());
+	Object.assign(config, globalConfig);
+
+	// Merge profile config (if specified and exists)
+	if (profileName && profileExists(profileName)) {
+		const profile = readProfile(profileName);
+		if (profile) {
+			const profileConfig = getProfileConfigFields(profile);
+			Object.assign(config, profileConfig);
+		}
+	}
+
+	// Merge local config (takes precedence)
+	const localConfig = readConfig(getLocalConfigPath(basePath));
+	Object.assign(config, localConfig);
+
+	return config;
+}
+
+/**
+ * Get the rules prompt with profile support
+ * Resolution order: local → profile → global → default
+ */
+export function getRulesPromptWithProfile(
+	profileName?: string,
+	basePath: string = process.cwd(),
+): string {
+	// Try local rules first (always highest priority)
+	const localRules = readRules(getLocalRulesPath(basePath));
+	if (localRules) {
+		return localRules;
+	}
+
+	// Try profile rules (if specified and exists)
+	if (profileName && profileExists(profileName)) {
+		const profileRules = readProfileRules(profileName);
+		if (profileRules) {
+			return profileRules;
+		}
+	}
+
+	// Fall back to global rules
+	const globalRules = readRules(getGlobalRulesPath());
+	if (globalRules) {
+		return globalRules;
+	}
+
+	// Return default rules
+	return DEFAULT_RULES;
+}

package/src/lib/history.ts

@@ -0,0 +1,139 @@
+/**
+ * History management for file operations
+ *
+ * Logs file moves to ~/.tidy/history.json for undo functionality
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { ensureDirectory } from "../utils/files.ts";
+
+const HISTORY_DIR = ".tidy";
+const HISTORY_FILE = "history.json";
+
+/**
+ * Get the history file path
+ */
+function getHistoryPath(): string {
+  return join(homedir(), HISTORY_DIR, HISTORY_FILE);
+}
+
+/**
+ * History entry for a file operation
+ */
+export interface HistoryEntry {
+  /** Unique ID for this operation */
+  id: string;
+  /** Timestamp of operation */
+  timestamp: string;
+  /** Source directory */
+  source: string;
+  /** Target directory */
+  target: string;
+  /** Files that were moved */
+  moves: Array<{
+    source: string;
+    destination: string;
+    timestamp: string;
+  }>;
+}
+
+/**
+ * Read history from file
+ */
+export function readHistory(): HistoryEntry[] {
+  const historyPath = getHistoryPath();
+
+  if (!existsSync(historyPath)) {
+    return [];
+  }
+
+  try {
+    const content = readFileSync(historyPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Write history to file
+ */
+function writeHistory(history: HistoryEntry[]): void {
+  const historyPath = getHistoryPath();
+  ensureDirectory(dirname(historyPath));
+  writeFileSync(historyPath, JSON.stringify(history, null, 2), "utf-8");
+}
+
+/**
+ * Create a new history entry
+ */
+export function createHistoryEntry(
+  source: string,
+  target: string,
+): HistoryEntry {
+  return {
+    id: Date.now().toString(),
+    timestamp: new Date().toISOString(),
+    source,
+    target,
+    moves: [],
+  };
+}
+
+/**
+ * Add a file move to history entry
+ */
+export function addMoveToHistory(
+  entry: HistoryEntry,
+  source: string,
+  destination: string,
+): void {
+  entry.moves.push({
+    source,
+    destination,
+    timestamp: new Date().toISOString(),
+  });
+}
+
+/**
+ * Save a history entry
+ */
+export function saveHistoryEntry(entry: HistoryEntry): void {
+  const history = readHistory();
+  history.unshift(entry);
+  writeHistory(history);
+}
+
+/**
+ * Get history entry by ID
+ */
+export function getHistoryEntry(id: string): HistoryEntry | null {
+  const history = readHistory();
+  return history.find((entry) => entry.id === id) || null;
+}
+
+/**
+ * Get the last N history entries
+ */
+export function getRecentHistory(limit: number = 10): HistoryEntry[] {
+  const history = readHistory();
+  return history.slice(0, limit);
+}
+
+/**
+ * Delete history entry by ID
+ */
+export function deleteHistoryEntry(id: string): void {
+  const history = readHistory();
+  const filtered = history.filter((entry) => entry.id !== id);
+  writeHistory(filtered);
+}
+
+/**
+ * Clear all history
+ */
+export function clearHistory(): void {
+  writeHistory([]);
+}

package/src/lib/opencode.ts

@@ -20,7 +20,11 @@ import type {
 	OrganizationProposal,
 } from "../types/organizer.ts";
 import { fileExists } from "../utils/files.ts";
-import { expandPath, getRulesPrompt, resolveConfig } from "./config.ts";
+import {
+	expandPath,
+	getRulesPromptWithProfile,
+	resolveConfigWithProfile,
+} from "./config.ts";
 
 const execAsync = promisify(exec);
 
@@ -169,6 +173,10 @@ export interface AnalyzeFilesOptions {
 	instructions?: string;
 	/** Model override */
 	model?: ModelSelection;
+	/** Existing folders in target directory for consistency */
+	existingFolders?: string[];
+	/** Profile name to use for config and rules */
+	profileName?: string;
 }
 
 /**
@@ -311,7 +319,7 @@ export async function checkConflicts(
 export async function analyzeFiles(
 	options: AnalyzeFilesOptions,
 ): Promise<OrganizationProposal> {
-	const { files, targetDir, instructions, model } = options;
+	const { files, targetDir, instructions, model, existingFolders, profileName } = options;
 
 	if (files.length === 0) {
 		return {
@@ -325,18 +333,28 @@ export async function analyzeFiles(
 	const opencodeClient = await getClient();
 	const sid = await getSessionId();
 
-	// Get configuration
-	const config = resolveConfig();
-	const rulesPrompt = getRulesPrompt();
+	// Get configuration with profile awareness
+	const config = resolveConfigWithProfile(profileName);
+	const rulesPrompt = getRulesPromptWithProfile(profileName);
 
 	// Build the prompt
 	const filesJson = formatFilesForPrompt(files);
 
+	// Build existing folders section if available
+	const existingFoldersSection = existingFolders?.length
+		? `
+EXISTING FOLDERS in target directory:
+${existingFolders.join("\n")}
+
+IMPORTANT: Prefer using these existing folders when appropriate. Only create new folders when no suitable existing folder matches the file's category.
+`
+		: "";
+
 	const userPrompt = `
 Analyze the following files and organize them according to the rules.
 
 Target directory: ${targetDir}
-
+${existingFoldersSection}
 ${instructions ? `Additional instructions: ${instructions}\n` : ""}
 Files to organize:
 ${filesJson}