tidyf 1.0.2 → 1.0.3

package/dist/index.js

@@ -13671,6 +13671,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:
@@ -13822,7 +13836,7 @@ function getDefaultRules() {
 }
 // src/lib/scanner.ts
 import { readdir, stat, readFile } from "fs/promises";
-import { join as join2, extname as extname2, basename } from "path";
+import { join as join2, extname as extname2, basename, relative } from "path";
 
 // node_modules/mime-types/index.js
 /*!
@@ -13871,6 +13885,55 @@ function populateMaps(extensions, types) {
 }
 
 // src/lib/scanner.ts
+async function scanFolderStructure(dirPath, options = {}) {
+  const {
+    maxDepth = 3,
+    includeEmpty = false,
+    ignore = [],
+    maxFolders = 100
+  } = options;
+  const folders = [];
+  await scanFoldersInternal(dirPath, dirPath, 0, maxDepth, includeEmpty, ignore, folders, maxFolders);
+  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, currentPath, currentDepth, maxDepth, includeEmpty, ignore, folders, maxFolders) {
+  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;
+      if (entry.name.startsWith("."))
+        continue;
+      if (shouldIgnore(entry.name, ignore))
+        continue;
+      const fullPath = join2(currentPath, entry.name);
+      const relativePath = relative(basePath, fullPath);
+      if (!includeEmpty) {
+        try {
+          const contents = await readdir(fullPath);
+          if (contents.length === 0)
+            continue;
+        } catch {
+          continue;
+        }
+      }
+      folders.push(relativePath);
+      await scanFoldersInternal(basePath, fullPath, currentDepth + 1, maxDepth, includeEmpty, ignore, folders, maxFolders);
+    }
+  } catch {}
+}
 async function scanDirectory(dirPath, options = {}) {
   const {
     recursive = false,
@@ -16578,7 +16641,7 @@ async function checkConflicts(proposal) {
   };
 }
 async function analyzeFiles(options) {
-  const { files, targetDir, instructions, model } = options;
+  const { files, targetDir, instructions, model, existingFolders } = options;
   if (files.length === 0) {
     return {
       proposals: [],
@@ -16592,11 +16655,18 @@ async function analyzeFiles(options) {
   const config = resolveConfig();
   const rulesPrompt = getRulesPrompt();
   const filesJson = formatFilesForPrompt(files);
+  const existingFoldersSection = existingFolders?.length ? `
+EXISTING FOLDERS in target directory:
+${existingFolders.join(`
+`)}
+
+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}
 ` : ""}
 Files to organize:
@@ -16989,13 +17059,25 @@ async function organizeCommand(options) {
     return;
   }
   M2.info(`Total size: ${formatFileSize(files.reduce((sum, f) => sum + f.size, 0))}`);
+  let existingFolders = [];
+  try {
+    existingFolders = await scanFolderStructure(targetPath, {
+      maxDepth: 3,
+      includeEmpty: false,
+      ignore: config.ignore
+    });
+    if (existingFolders.length > 0) {
+      M2.info(`Found ${import_picocolors4.default.bold(String(existingFolders.length))} existing folders in target`);
+    }
+  } catch {}
   spinner.start("Analyzing files with AI...");
   let proposal;
   try {
     proposal = await analyzeFiles({
       files,
       targetDir: targetPath,
-      model: parseModelString(options.model)
+      model: parseModelString(options.model),
+      existingFolders
     });
     spinner.stop("Analysis complete");
   } catch (error) {
@@ -17077,7 +17159,8 @@ async function organizeCommand(options) {
               files,
               targetDir: targetPath,
               instructions: newInstructions || undefined,
-              model: parseModelString(options.model)
+              model: parseModelString(options.model),
+              existingFolders
             });
             spinner.stop("Analysis complete");
             displayAllProposals(proposal);
@@ -17105,7 +17188,8 @@ async function organizeCommand(options) {
               files,
               targetDir: targetPath,
               instructions: newInstructions || undefined,
-              model: pickedModel
+              model: pickedModel,
+              existingFolders
             });
             spinner.stop("Analysis complete");
             displayAllProposals(proposal);
@@ -17123,6 +17207,26 @@ async function organizeCommand(options) {
 }
 // src/commands/watch.ts
 var import_picocolors5 = __toESM(require_picocolors(), 1);
+var folderCache = [];
+var lastFolderScan = 0;
+var FOLDER_CACHE_TTL = 5 * 60 * 1000;
+async function getExistingFolders(targetPath, ignore = []) {
+  const now = Date.now();
+  if (now - lastFolderScan > FOLDER_CACHE_TTL) {
+    try {
+      folderCache = await scanFolderStructure(targetPath, {
+        maxDepth: 3,
+        includeEmpty: false,
+        ignore
+      });
+      lastFolderScan = now;
+    } catch {}
+  }
+  return folderCache;
+}
+function invalidateFolderCache() {
+  lastFolderScan = 0;
+}
 function displayProposalBrief(proposals) {
   for (const prop of proposals) {
     const icon = getFileIcon(prop.file.name);
@@ -17143,6 +17247,9 @@ async function executeProposalsSilent(proposals) {
       failed++;
     }
   }
+  if (success > 0) {
+    invalidateFolderCache();
+  }
   return { success, failed };
 }
 async function interactiveReview(proposal) {
@@ -17233,10 +17340,12 @@ ${import_picocolors5.default.green("+")} ${newFilePaths.length} new file(s) dete
     s.start("Analyzing files with AI...");
     let proposal;
     try {
+      const existingFolders = await getExistingFolders(targetPath, config.ignore);
       proposal = await analyzeFiles({
         files,
         targetDir: targetPath,
-        model: parseModelString(options.model)
+        model: parseModelString(options.model),
+        existingFolders
       });
       s.stop("Analysis complete");
     } catch (error) {
@@ -17281,10 +17390,12 @@ ${import_picocolors5.default.green("+")} ${newFilePaths.length} new file(s) dete
         const s = Y2();
         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)
+            model: parseModelString(options.model),
+            existingFolders
           });
           s.stop("Analysis complete");
           await interactiveReview(proposal);

package/package.json

@@ -1,58 +1,59 @@
 {
-  "name": "tidyf",
-  "version": "1.0.2",
-  "description": "AI-powered file organizer using opencode.ai",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "tidyf": "./dist/cli.js",
-    "td": "./dist/cli.js",
-    "tidyfiles": "./dist/cli.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yafyx/tidyf.git"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "scripts": {
-    "start": "node dist/cli.js",
-    "dev": "bun --watch src/cli.ts",
-    "build": "bun build src/cli.ts --outdir=dist --target=node --format=esm && bun build src/index.ts --outdir=dist --target=node --format=esm",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "bun run build"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "keywords": [
-    "file-organizer",
-    "ai",
-    "opencode",
-    "cli",
-    "downloads",
-    "tidy",
-    "automation"
-  ],
-  "author": "",
-  "license": "MIT",
-  "files": [
-    "dist",
-    "src"
-  ],
-  "dependencies": {
-    "@clack/prompts": "^0.11.0",
-    "@opencode-ai/sdk": "^1.0.155",
-    "chokidar": "^3.5.3",
-    "commander": "^12.1.0",
-    "mime-types": "^2.1.35",
-    "picocolors": "^1.1.1"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/mime-types": "^2.1.4",
-    "typescript": "^5.7.2"
-  }
+	"name": "tidyf",
+	"version": "1.0.3",
+	"description": "AI-powered file organizer using opencode.ai",
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"tidyf": "./dist/cli.js",
+		"td": "./dist/cli.js",
+		"tidyfiles": "./dist/cli.js"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/yafyx/tidyf.git"
+	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org/"
+	},
+	"scripts": {
+		"start": "node dist/cli.js",
+		"dev": "bun --watch src/cli.ts",
+		"build": "bun build src/cli.ts --outdir=dist --target=node --format=esm && bun build src/index.ts --outdir=dist --target=node --format=esm",
+		"typecheck": "tsc --noEmit",
+		"prepublishOnly": "bun run build"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"keywords": [
+		"file-organizer",
+		"ai",
+		"opencode",
+		"cli",
+		"downloads",
+		"tidy",
+		"automation"
+	],
+	"author": "",
+	"license": "MIT",
+	"files": [
+		"dist",
+		"src"
+	],
+	"dependencies": {
+		"@clack/prompts": "^0.11.0",
+		"@opencode-ai/sdk": "^1.0.155",
+		"chokidar": "^3.5.3",
+		"commander": "^12.1.0",
+		"mime-types": "^2.1.35",
+		"picocolors": "^1.1.1",
+		"simple-update-notifier": "^2.0.0"
+	},
+	"devDependencies": {
+		"@types/bun": "latest",
+		"@types/mime-types": "^2.1.4",
+		"typescript": "^5.7.2"
+	}
 }

package/src/cli.ts

@@ -5,16 +5,24 @@
  */
 
 import { Command } from "commander";
+import updateNotifier from "simple-update-notifier";
+import { createRequire } from "module";
 import { configCommand } from "./commands/config.ts";
 import { organizeCommand } from "./commands/organize.ts";
 import { watchCommand } from "./commands/watch.ts";
 
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+
+// Check for updates (non-blocking, cached for 1 day)
+updateNotifier({ pkg });
+
 const program = new Command();
 
 program
 	.name("tidyf")
 	.description("AI-powered file organizer using opencode.ai")
-	.version("1.0.0");
+	.version(pkg.version);
 
 // Default command - organize files
 program

package/src/commands/organize.ts

@@ -19,7 +19,7 @@ import {
   resolveConfig,
 } from "../lib/config.ts";
 import { analyzeFiles, cleanup } from "../lib/opencode.ts";
-import { scanDirectory } from "../lib/scanner.ts";
+import { scanDirectory, scanFolderStructure } from "../lib/scanner.ts";
 import type {
   FileMoveProposal,
   MoveResult,
@@ -276,6 +276,21 @@ export async function organizeCommand(options: OrganizeOptions): Promise<void> {
     `Total size: ${formatFileSize(files.reduce((sum, f) => sum + f.size, 0))}`,
   );
 
+  // Scan existing folder structure in target directory
+  let existingFolders: string[] = [];
+  try {
+    existingFolders = await scanFolderStructure(targetPath, {
+      maxDepth: 3,
+      includeEmpty: false,
+      ignore: config.ignore,
+    });
+    if (existingFolders.length > 0) {
+      p.log.info(`Found ${color.bold(String(existingFolders.length))} existing folders in target`);
+    }
+  } catch {
+    // Target directory might not exist yet - OK
+  }
+
   // Analyze with AI
   spinner.start("Analyzing files with AI...");
 
@@ -285,6 +300,7 @@ export async function organizeCommand(options: OrganizeOptions): Promise<void> {
       files,
       targetDir: targetPath,
       model: parseModelString(options.model),
+      existingFolders,
     });
     spinner.stop("Analysis complete");
   } catch (error: any) {
@@ -383,6 +399,7 @@ export async function organizeCommand(options: OrganizeOptions): Promise<void> {
               targetDir: targetPath,
               instructions: newInstructions || undefined,
               model: parseModelString(options.model),
+              existingFolders,
             });
             spinner.stop("Analysis complete");
             displayAllProposals(proposal);
@@ -416,6 +433,7 @@ export async function organizeCommand(options: OrganizeOptions): Promise<void> {
               targetDir: targetPath,
               instructions: newInstructions || undefined,
               model: pickedModel,
+              existingFolders,
             });
             spinner.stop("Analysis complete");
             displayAllProposals(proposal);

package/src/commands/watch.ts

@@ -11,7 +11,7 @@ import {
   resolveConfig,
 } from "../lib/config.ts";
 import { analyzeFiles, cleanup } from "../lib/opencode.ts";
-import { getFileMetadata } from "../lib/scanner.ts";
+import { getFileMetadata, scanFolderStructure } from "../lib/scanner.ts";
 import { createWatcher, type FileWatcher } from "../lib/watcher.ts";
 import type {
   FileMetadata,
@@ -23,6 +23,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 +92,11 @@ async function executeProposalsSilent(
     }
   }
 
+  // Invalidate folder cache since new folders may have been created
+  if (success > 0) {
+    invalidateFolderCache();
+  }
+
   return { success, failed };
 }
 
@@ -207,10 +247,12 @@ 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,
       });
       s.stop("Analysis complete");
     } catch (error: any) {
@@ -276,10 +318,12 @@ 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,
           });
           s.stop("Analysis complete");
 

package/src/lib/config.ts

@@ -94,6 +94,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:

package/src/lib/opencode.ts

@@ -169,6 +169,8 @@ export interface AnalyzeFilesOptions {
 	instructions?: string;
 	/** Model override */
 	model?: ModelSelection;
+	/** Existing folders in target directory for consistency */
+	existingFolders?: string[];
 }
 
 /**
@@ -311,7 +313,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 } = options;
 
 	if (files.length === 0) {
 		return {
@@ -332,11 +334,21 @@ export async function analyzeFiles(
 	// 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}

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
  */