tidyf 1.0.2 → 1.1.0

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,
+  }));
+}

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;
+}