tidyf 1.0.3 → 1.1.0

package/src/lib/profiles.ts

@@ -0,0 +1,367 @@
+/**
+ * Profile management for tidyf
+ *
+ * Handles CRUD operations for profiles stored in ~/.tidy/profiles/
+ * Each profile is a directory containing settings.json and optionally rules.md
+ */
+
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	rmSync,
+	writeFileSync,
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { Profile, ProfileMetadata, ProfileExport } from "../types/profile.ts";
+import type { TidyConfig } from "../types/config.ts";
+import { getPreset } from "./presets.ts";
+
+const CONFIG_DIR = ".tidy";
+const PROFILES_DIR = "profiles";
+const SETTINGS_FILE = "settings.json";
+const RULES_FILE = "rules.md";
+
+/**
+ * Get the profiles directory path
+ */
+export function getProfilesDir(): string {
+	return join(homedir(), CONFIG_DIR, PROFILES_DIR);
+}
+
+/**
+ * Get a specific profile's directory path
+ */
+export function getProfileDir(name: string): string {
+	return join(getProfilesDir(), name);
+}
+
+/**
+ * Get the path to a profile's settings.json
+ */
+export function getProfileConfigPath(name: string): string {
+	return join(getProfileDir(name), SETTINGS_FILE);
+}
+
+/**
+ * Get the path to a profile's rules.md
+ */
+export function getProfileRulesPath(name: string): string {
+	return join(getProfileDir(name), RULES_FILE);
+}
+
+/**
+ * Ensure profiles directory exists
+ */
+export function ensureProfilesDir(): void {
+	const profilesDir = getProfilesDir();
+	if (!existsSync(profilesDir)) {
+		mkdirSync(profilesDir, { recursive: true });
+	}
+}
+
+/**
+ * Validate a profile name
+ * @returns Object with valid boolean and optional error message
+ */
+export function validateProfileName(name: string): { valid: boolean; error?: string } {
+	// Must be non-empty and max 50 characters
+	if (!name || name.length === 0) {
+		return { valid: false, error: "Profile name cannot be empty" };
+	}
+	if (name.length > 50) {
+		return { valid: false, error: "Profile name must be 50 characters or less" };
+	}
+
+	// Alphanumeric, hyphens, underscores only
+	if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+		return {
+			valid: false,
+			error: "Profile name can only contain letters, numbers, hyphens, and underscores",
+		};
+	}
+
+	// Reserved names
+	const reserved = ["default", "global", "local", "none", "profiles"];
+	if (reserved.includes(name.toLowerCase())) {
+		return { valid: false, error: `"${name}" is a reserved name` };
+	}
+
+	return { valid: true };
+}
+
+/**
+ * Check if a profile exists
+ */
+export function profileExists(name: string): boolean {
+	return existsSync(getProfileDir(name));
+}
+
+/**
+ * List all profiles with metadata
+ */
+export function listProfiles(): ProfileMetadata[] {
+	const profilesDir = getProfilesDir();
+
+	if (!existsSync(profilesDir)) {
+		return [];
+	}
+
+	const profiles: ProfileMetadata[] = [];
+
+	try {
+		const entries = readdirSync(profilesDir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			if (entry.name.startsWith(".")) continue;
+
+			const profileConfigPath = getProfileConfigPath(entry.name);
+			const profileRulesPath = getProfileRulesPath(entry.name);
+
+			// Must have settings.json to be a valid profile
+			if (!existsSync(profileConfigPath)) continue;
+
+			try {
+				const content = readFileSync(profileConfigPath, "utf-8");
+				const profile: Profile = JSON.parse(content);
+
+				profiles.push({
+					name: entry.name,
+					description: profile.description,
+					createdAt: profile.createdAt,
+					modifiedAt: profile.modifiedAt,
+					hasCustomRules: existsSync(profileRulesPath),
+				});
+			} catch {
+				// Skip invalid profiles
+			}
+		}
+	} catch {
+		return [];
+	}
+
+	// Sort alphabetically by name
+	profiles.sort((a, b) => a.name.localeCompare(b.name));
+
+	return profiles;
+}
+
+/**
+ * Read a profile's configuration
+ */
+export function readProfile(name: string): Profile | null {
+	const configPath = getProfileConfigPath(name);
+
+	if (!existsSync(configPath)) {
+		return null;
+	}
+
+	try {
+		const content = readFileSync(configPath, "utf-8");
+		const profile: Profile = JSON.parse(content);
+		// Ensure name matches directory name
+		profile.name = name;
+		return profile;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Read a profile's custom rules (if any)
+ */
+export function readProfileRules(name: string): string | null {
+	const rulesPath = getProfileRulesPath(name);
+
+	if (!existsSync(rulesPath)) {
+		return null;
+	}
+
+	try {
+		return readFileSync(rulesPath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Write a profile's configuration
+ */
+export function writeProfile(name: string, profile: Profile): void {
+	ensureProfilesDir();
+
+	const profileDir = getProfileDir(name);
+	if (!existsSync(profileDir)) {
+		mkdirSync(profileDir, { recursive: true });
+	}
+
+	// Update metadata
+	const now = new Date().toISOString();
+	if (!profile.createdAt) {
+		profile.createdAt = now;
+	}
+	profile.modifiedAt = now;
+	profile.name = name;
+
+	const configPath = getProfileConfigPath(name);
+	writeFileSync(configPath, JSON.stringify(profile, null, 2), "utf-8");
+}
+
+/**
+ * Write custom rules for a profile
+ */
+export function writeProfileRules(name: string, rules: string): void {
+	ensureProfilesDir();
+
+	const profileDir = getProfileDir(name);
+	if (!existsSync(profileDir)) {
+		mkdirSync(profileDir, { recursive: true });
+	}
+
+	const rulesPath = getProfileRulesPath(name);
+	writeFileSync(rulesPath, rules, "utf-8");
+}
+
+/**
+ * Delete a profile
+ */
+export function deleteProfile(name: string): void {
+	const profileDir = getProfileDir(name);
+
+	if (existsSync(profileDir)) {
+		rmSync(profileDir, { recursive: true, force: true });
+	}
+}
+
+/**
+ * Copy a profile to a new name
+ */
+export function copyProfile(source: string, destination: string): void {
+	const sourceProfile = readProfile(source);
+	if (!sourceProfile) {
+		throw new Error(`Source profile "${source}" not found`);
+	}
+
+	if (profileExists(destination)) {
+		throw new Error(`Destination profile "${destination}" already exists`);
+	}
+
+	// Copy config with new name and reset timestamps
+	const newProfile: Profile = {
+		...sourceProfile,
+		name: destination,
+		createdAt: new Date().toISOString(),
+		modifiedAt: new Date().toISOString(),
+	};
+
+	writeProfile(destination, newProfile);
+
+	// Copy rules if they exist
+	const sourceRules = readProfileRules(source);
+	if (sourceRules) {
+		writeProfileRules(destination, sourceRules);
+	}
+}
+
+/**
+ * Export a profile for sharing
+ */
+export function exportProfile(name: string): ProfileExport {
+	const profile = readProfile(name);
+	if (!profile) {
+		throw new Error(`Profile "${name}" not found`);
+	}
+
+	const rules = readProfileRules(name);
+
+	return {
+		version: "1.0",
+		exportedAt: new Date().toISOString(),
+		profile,
+		rules: rules || undefined,
+	};
+}
+
+/**
+ * Import a profile from an export
+ * @param data The exported profile data
+ * @param overrideName Optional name to use instead of the one in the export
+ * @returns The name of the imported profile
+ */
+export function importProfile(data: ProfileExport, overrideName?: string): string {
+	const name = overrideName || data.profile.name;
+
+	const validation = validateProfileName(name);
+	if (!validation.valid) {
+		throw new Error(validation.error);
+	}
+
+	if (profileExists(name)) {
+		throw new Error(`Profile "${name}" already exists`);
+	}
+
+	// Import with updated timestamps
+	const profile: Profile = {
+		...data.profile,
+		name,
+		createdAt: new Date().toISOString(),
+		modifiedAt: new Date().toISOString(),
+	};
+
+	writeProfile(name, profile);
+
+	// Import rules if present
+	if (data.rules) {
+		writeProfileRules(name, data.rules);
+	}
+
+	return name;
+}
+
+/**
+ * Get the config fields that should be merged from a profile
+ * (excludes metadata fields)
+ */
+export function getProfileConfigFields(profile: Profile): Partial<TidyConfig> {
+	const { name, description, createdAt, modifiedAt, ...configFields } = profile;
+	return configFields;
+}
+
+/**
+ * Install a built-in preset as a profile
+ * @param presetName The name of the preset (developer, creative, student, downloads)
+ * @param profileName Optional custom name for the installed profile
+ * @returns The name of the installed profile
+ */
+export function installPreset(presetName: string, profileName?: string): string {
+	const preset = getPreset(presetName);
+	if (!preset) {
+		throw new Error(`Preset "${presetName}" not found. Available: developer, creative, student, downloads`);
+	}
+
+	const name = profileName || presetName;
+
+	const validation = validateProfileName(name);
+	if (!validation.valid) {
+		throw new Error(validation.error);
+	}
+
+	if (profileExists(name)) {
+		throw new Error(`Profile "${name}" already exists. Use a different name or delete the existing profile.`);
+	}
+
+	const profile: Profile = {
+		...preset.profile,
+		name,
+		createdAt: new Date().toISOString(),
+		modifiedAt: new Date().toISOString(),
+	};
+
+	writeProfile(name, profile);
+	writeProfileRules(name, preset.rules);
+
+	return name;
+}

package/src/types/organizer.ts

@@ -22,6 +22,8 @@ export interface FileMetadata {
   mimeType?: string;
   /** Optional content preview (first N bytes/lines) */
   contentPreview?: string;
+  /** Content hash for duplicate detection */
+  hash?: string;
 }
 
 /**
@@ -56,6 +58,18 @@ export interface FileMoveProposal {
   conflictExists: boolean;
 }
 
+/**
+ * A group of duplicate files (same content hash)
+ */
+export interface DuplicateGroup {
+  /** Content hash shared by all files */
+  hash: string;
+  /** Files with identical content */
+  files: FileMetadata[];
+  /** Total wasted space (all but one copy) */
+  wastedBytes: number;
+}
+
 /**
  * Result of AI analysis
  */
@@ -68,6 +82,8 @@ export interface OrganizationProposal {
   uncategorized: FileMetadata[];
   /** Timestamp of analysis */
   analyzedAt: Date;
+  /** Detected duplicate file groups */
+  duplicates?: DuplicateGroup[];
 }
 
 /**
@@ -88,6 +104,12 @@ export interface OrganizeOptions {
   target?: string;
   /** Model override */
   model?: string;
+  /** Profile name to use */
+  profile?: string;
+  /** Output JSON instead of interactive UI */
+  json?: boolean;
+  /** Detect duplicate files by content hash */
+  detectDuplicates?: boolean;
 }
 
 /**
@@ -104,6 +126,8 @@ export interface WatchOptions {
   queue?: boolean;
   /** Model override */
   model?: string;
+  /** Profile name to use */
+  profile?: string;
 }
 
 /**

package/src/types/profile.ts

@@ -0,0 +1,70 @@
+/**
+ * Profile types for tidyf
+ *
+ * Profiles allow users to create named configuration presets
+ * that bundle source/target paths, AI model preferences, ignore patterns,
+ * and optionally custom organization rules.
+ */
+
+import type { TidyConfig } from "./config.ts";
+
+/**
+ * Profile configuration - extends TidyConfig with metadata
+ * Profiles inherit from global config, only overriding specified fields.
+ */
+export interface Profile extends Partial<TidyConfig> {
+	/** Profile name (directory name) */
+	name: string;
+	/** Human-readable description */
+	description?: string;
+	/** When the profile was created */
+	createdAt?: string;
+	/** When the profile was last modified */
+	modifiedAt?: string;
+}
+
+/**
+ * Profile metadata for listing (without full config)
+ */
+export interface ProfileMetadata {
+	/** Profile name */
+	name: string;
+	/** Human-readable description */
+	description?: string;
+	/** When the profile was created */
+	createdAt?: string;
+	/** When the profile was last modified */
+	modifiedAt?: string;
+	/** Whether profile has custom rules.md */
+	hasCustomRules: boolean;
+}
+
+/**
+ * Options for profile command
+ */
+export interface ProfileCommandOptions {
+	/** Subcommand: list, create, edit, delete, show, copy, export, import */
+	action?: string;
+	/** Profile name for operations */
+	name?: string;
+	/** Additional arguments (e.g., destination for copy) */
+	args?: string[];
+	/** Create from current effective config */
+	fromCurrent?: boolean;
+	/** Force operation without confirmation */
+	force?: boolean;
+}
+
+/**
+ * Export format for profiles (for sharing)
+ */
+export interface ProfileExport {
+	/** Export format version */
+	version: string;
+	/** When the export was created */
+	exportedAt: string;
+	/** The profile configuration */
+	profile: Profile;
+	/** Optional custom rules content */
+	rules?: string;
+}

package/src/utils/files.ts

@@ -2,7 +2,8 @@
  * File system utilities for tidy
  */
 
-import { rename, mkdir, access, copyFile, unlink, stat } from "fs/promises";
+import { rename, mkdir, access, copyFile, unlink, stat, readFile } from "fs/promises";
+import { createHash } from "crypto";
 import { dirname, join, basename, extname } from "path";
 import { existsSync } from "fs";
 import type { MoveResult, MoveStatus } from "../types/organizer.ts";
@@ -196,3 +197,16 @@ export async function isFile(path: string): Promise<boolean> {
     return false;
   }
 }
+
+/**
+ * Compute a hash of file contents for duplicate detection
+ * Uses MD5 for speed (not cryptographic security)
+ */
+export async function computeFileHash(filePath: string): Promise<string | null> {
+  try {
+    const content = await readFile(filePath);
+    return createHash("md5").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}