tidyf 1.0.2 → 1.1.0

package/src/lib/scanner.ts

@@ -3,12 +3,114 @@
  */
 
 import { readdir, stat, readFile } from "fs/promises";
-import { join, extname, basename } from "path";
+import { join, extname, basename, relative } from "path";
 import { lookup as lookupMimeType } from "mime-types";
 import type { FileMetadata } from "../types/organizer.ts";
 import { shouldIgnore } from "./config.ts";
 import { isDirectory, isFile } from "../utils/files.ts";
 
+/**
+ * Options for scanning folder structure
+ */
+export interface ScanFolderOptions {
+  /** Maximum depth to scan (default: 3) */
+  maxDepth?: number;
+  /** Include empty folders (default: false) */
+  includeEmpty?: boolean;
+  /** Patterns to ignore */
+  ignore?: string[];
+  /** Maximum number of folders to return (default: 100) */
+  maxFolders?: number;
+}
+
+/**
+ * Scan a directory and return existing folder structure as relative paths
+ * Used to inform AI about existing organization
+ */
+export async function scanFolderStructure(
+  dirPath: string,
+  options: ScanFolderOptions = {}
+): Promise<string[]> {
+  const {
+    maxDepth = 3,
+    includeEmpty = false,
+    ignore = [],
+    maxFolders = 100,
+  } = options;
+
+  const folders: string[] = [];
+
+  await scanFoldersInternal(dirPath, dirPath, 0, maxDepth, includeEmpty, ignore, folders, maxFolders);
+
+  // Sort by depth (shallower first) then alphabetically
+  folders.sort((a, b) => {
+    const depthA = a.split("/").length;
+    const depthB = b.split("/").length;
+    if (depthA !== depthB) return depthA - depthB;
+    return a.localeCompare(b);
+  });
+
+  return folders.slice(0, maxFolders);
+}
+
+async function scanFoldersInternal(
+  basePath: string,
+  currentPath: string,
+  currentDepth: number,
+  maxDepth: number,
+  includeEmpty: boolean,
+  ignore: string[],
+  folders: string[],
+  maxFolders: number
+): Promise<void> {
+  if (currentDepth >= maxDepth || folders.length >= maxFolders) {
+    return;
+  }
+
+  try {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (folders.length >= maxFolders) break;
+
+      if (!entry.isDirectory()) continue;
+
+      // Skip hidden folders and ignored patterns
+      if (entry.name.startsWith(".")) continue;
+      if (shouldIgnore(entry.name, ignore)) continue;
+
+      const fullPath = join(currentPath, entry.name);
+      const relativePath = relative(basePath, fullPath);
+
+      // Check if folder has contents (if we care about empty folders)
+      if (!includeEmpty) {
+        try {
+          const contents = await readdir(fullPath);
+          if (contents.length === 0) continue;
+        } catch {
+          continue;
+        }
+      }
+
+      folders.push(relativePath);
+
+      // Recursively scan subdirectories
+      await scanFoldersInternal(
+        basePath,
+        fullPath,
+        currentDepth + 1,
+        maxDepth,
+        includeEmpty,
+        ignore,
+        folders,
+        maxFolders
+      );
+    }
+  } catch {
+    // Silently skip directories we can't read
+  }
+}
+
 /**
  * Options for scanning a directory
  */

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