tidyf 1.0.3 → 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,8 +9,10 @@ import {
   initGlobalConfig,
   parseModelString,
   resolveConfig,
+  resolveConfigWithProfile,
 } from "../lib/config.ts";
 import { analyzeFiles, cleanup } from "../lib/opencode.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 {
@@ -152,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[];
@@ -253,6 +273,7 @@ export async function watchCommand(options: WatchOptions): Promise<void> {
         targetDir: targetPath,
         model: parseModelString(options.model),
         existingFolders,
+        profileName: options.profile,
       });
       s.stop("Analysis complete");
     } catch (error: any) {
@@ -324,6 +345,7 @@ export async function watchCommand(options: WatchOptions): Promise<void> {
             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";
@@ -347,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);
 
@@ -171,6 +175,8 @@ export interface AnalyzeFilesOptions {
 	model?: ModelSelection;
 	/** Existing folders in target directory for consistency */
 	existingFolders?: string[];
+	/** Profile name to use for config and rules */
+	profileName?: string;
 }
 
 /**
@@ -313,7 +319,7 @@ export async function checkConflicts(
 export async function analyzeFiles(
 	options: AnalyzeFilesOptions,
 ): Promise<OrganizationProposal> {
-	const { files, targetDir, instructions, model, existingFolders } = options;
+	const { files, targetDir, instructions, model, existingFolders, profileName } = options;
 
 	if (files.length === 0) {
 		return {
@@ -327,9 +333,9 @@ 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);

package/src/lib/presets.ts

@@ -0,0 +1,257 @@
+/**
+ * Built-in profile presets for common use cases
+ */
+
+import type { Profile } from "../types/profile.ts";
+
+export interface PresetDefinition {
+  name: string;
+  description: string;
+  profile: Omit<Profile, "name" | "createdAt" | "modifiedAt">;
+  rules: string;
+}
+
+export const PRESET_DEFINITIONS: PresetDefinition[] = [
+  {
+    name: "developer",
+    description: "Organize source code, configs, and project files",
+    profile: {
+      description: "Developer-focused organization for code and configs",
+      defaultTarget: "~/Documents/Dev",
+    },
+    rules: `# Developer Profile Rules
+
+You are organizing files for a software developer. Focus on project structure and code organization.
+
+## Categories
+
+### Code
+- Source files: .ts, .tsx, .js, .jsx, .py, .go, .rs, .java, .c, .cpp, .swift, .kt
+- Subcategorize by language family: JavaScript, Python, Go, Rust, Swift, etc.
+
+### Config
+- Configuration files: .json, .yaml, .yml, .toml, .env, .ini
+- Subcategorize: Project Config, Editor Config, CI/CD
+
+### Documentation
+- README, CHANGELOG, LICENSE, .md files
+- API docs, design docs
+
+### Data
+- Database files, SQL scripts, seed data
+- JSON/CSV data files
+
+### Scripts
+- Shell scripts, batch files, automation scripts
+- Build scripts, deployment scripts
+
+## Strategy
+
+1. **Group by project** - If filename contains project identifiers, keep files together
+2. **Separate configs from code** - Configs go to their own folder
+3. **Archive old files** - Anything with "old", "backup", or date suffixes
+
+## Output Format
+
+Return JSON:
+\`\`\`json
+{
+  "proposals": [{ "file": "name", "destination": "Code/JavaScript/project", "category": {...} }],
+  "strategy": "...",
+  "uncategorized": []
+}
+\`\`\`
+`,
+  },
+  {
+    name: "creative",
+    description: "Organize images, videos, design files, and media",
+    profile: {
+      description: "Creative workflow for designers and content creators",
+      defaultTarget: "~/Documents/Creative",
+    },
+    rules: `# Creative Profile Rules
+
+You are organizing files for a designer or content creator. Focus on visual assets and media organization.
+
+## Categories
+
+### Images
+- Photos: .jpg, .jpeg, .png, .heic, .raw, .cr2, .nef
+- Graphics: .svg, .webp, .gif
+- Subcategorize: Photos, Screenshots, Icons, Illustrations
+
+### Design
+- Figma exports, Sketch files, PSD, AI
+- Subcategorize by project or client name if detectable
+
+### Video
+- .mp4, .mov, .avi, .mkv, .webm
+- Subcategorize: Raw Footage, Exports, Clips
+
+### Audio
+- .mp3, .wav, .aiff, .flac, .m4a
+- Subcategorize: Music, SFX, Voiceover
+
+### Fonts
+- .ttf, .otf, .woff, .woff2
+- Keep in centralized Fonts folder
+
+### 3D
+- .obj, .fbx, .blend, .gltf
+- 3D models and assets
+
+## Strategy
+
+1. **Date-based for photos** - Organize photos by YYYY/MM if dates detected in filename
+2. **Project-based for design** - Group by client or project name
+3. **Keep exports together** - Files with "export", "final", "v2" stay in same project folder
+
+## Output Format
+
+Return JSON:
+\`\`\`json
+{
+  "proposals": [{ "file": "name", "destination": "Images/Photos/2024/January", "category": {...} }],
+  "strategy": "...",
+  "uncategorized": []
+}
+\`\`\`
+`,
+  },
+  {
+    name: "student",
+    description: "Organize documents, notes, and academic materials",
+    profile: {
+      description: "Academic organization for students and researchers",
+      defaultTarget: "~/Documents/School",
+    },
+    rules: `# Student Profile Rules
+
+You are organizing files for a student. Focus on academic organization and study materials.
+
+## Categories
+
+### Notes
+- Text files, markdown notes, OneNote exports
+- Subcategorize by subject if detectable
+
+### Documents
+- PDFs, Word docs, essays, reports
+- Subcategorize: Assignments, Readings, Submissions
+
+### Slides
+- PowerPoint, Keynote, Google Slides exports
+- Lecture slides, presentations
+
+### Spreadsheets
+- Excel, CSV, data analysis files
+- Lab data, calculations
+
+### Textbooks
+- E-books: .epub, .mobi, .pdf (large PDFs)
+- Reference materials
+
+### Research
+- Papers, citations, bibliography files
+- Research data and notes
+
+## Strategy
+
+1. **Subject detection** - Look for subject names in filenames (math, history, physics, etc.)
+2. **Semester organization** - Group by term if dates/semesters detected
+3. **Assignment priority** - Files with "assignment", "hw", "lab" get special handling
+
+## Output Format
+
+Return JSON:
+\`\`\`json
+{
+  "proposals": [{ "file": "name", "destination": "Notes/Physics/Chapter1", "category": {...} }],
+  "strategy": "...",
+  "uncategorized": []
+}
+\`\`\`
+`,
+  },
+  {
+    name: "downloads",
+    description: "Aggressive cleanup for messy Downloads folders",
+    profile: {
+      description: "Fast cleanup for Downloads folder chaos",
+      defaultSource: "~/Downloads",
+      defaultTarget: "~/Documents/Organized",
+    },
+    rules: `# Downloads Cleanup Profile
+
+You are aggressively cleaning a messy Downloads folder. Be decisive and organize everything.
+
+## Categories
+
+### Installers
+- DMG, PKG, EXE, MSI, APP, DEB, RPM
+- Move to Installers folder, suggest deletion after install
+
+### Archives
+- ZIP, RAR, 7Z, TAR.GZ
+- Keep in Archives, note if should be extracted
+
+### Documents
+- PDF, DOCX, XLSX, PPTX, TXT
+- Subcategorize: Receipts, Manuals, Forms, Other
+
+### Images
+- All image formats
+- Screenshots go to Screenshots subfolder
+
+### Videos
+- All video formats
+- Downloads, Clips, Tutorials
+
+### Audio
+- All audio formats
+- Music, Podcasts, Recordings
+
+### Code
+- Source files, scripts, configs
+- Move to Development folder
+
+### Temporary
+- .tmp, .part, .crdownload, incomplete downloads
+- Flag for deletion
+
+## Strategy
+
+1. **Be aggressive** - Everything gets categorized, nothing stays in Downloads
+2. **Detect duplicates** - Files like "file (1).pdf" are duplicates
+3. **Date cleanup** - Old files (>30 days) can go to Archive
+4. **Installers cleanup** - Suggest keeping only latest versions
+
+## Output Format
+
+Return JSON:
+\`\`\`json
+{
+  "proposals": [{ "file": "name", "destination": "Documents/Receipts", "category": {...} }],
+  "strategy": "...",
+  "uncategorized": []
+}
+\`\`\`
+`,
+  },
+];
+
+export function getPresetNames(): string[] {
+  return PRESET_DEFINITIONS.map((p) => p.name);
+}
+
+export function getPreset(name: string): PresetDefinition | undefined {
+  return PRESET_DEFINITIONS.find((p) => p.name === name);
+}
+
+export function listPresets(): { name: string; description: string }[] {
+  return PRESET_DEFINITIONS.map((p) => ({
+    name: p.name,
+    description: p.description,
+  }));
+}